@tradejs/cli 3.1.29-beta.290 → 3.1.29-beta.292

package/dist/scripts/strategyResearch.js

@@ -35,6 +35,98 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+// src/lib/coreResearch/trace.ts
+async function* readCoreResearchTrace(filePaths) {
+  for (const inputPath of filePaths) {
+    const filePath = import_node_path.default.resolve(inputPath);
+    const input = (0, import_node_fs.createReadStream)(filePath);
+    const lines = import_node_readline.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)}`
+          );
+        }
+        yield event;
+      }
+    } finally {
+      lines.close();
+      input.destroy();
+    }
+  }
+}
+var import_node_fs, import_node_readline, import_node_path, summarizeCoreResearchTrace;
+var init_trace = __esm({
+  "src/lib/coreResearch/trace.ts"() {
+    "use strict";
+    import_node_fs = require("fs");
+    import_node_readline = __toESM(require("readline"));
+    import_node_path = __toESM(require("path"));
+    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 await (const event of readCoreResearchTrace(filePaths)) {
+        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
+            });
+        }
+      }
+      return {
+        events: Object.fromEntries(Object.entries(events).sort()),
+        skipCounts: Object.fromEntries(
+          Object.entries(skipCounts).sort(
+            ([leftKey, leftValue], [rightKey, rightValue]) => rightValue - leftValue || (leftKey < rightKey ? -1 : leftKey > rightKey ? 1 : 0)
+          )
+        ),
+        exitCodes: Object.fromEntries(
+          Object.entries(exitCodes).sort(
+            ([leftKey, leftValue], [rightKey, rightValue]) => rightValue - leftValue || (leftKey < rightKey ? -1 : leftKey > rightKey ? 1 : 0)
+          )
+        ),
+        ...policyExamples.length ? {
+          researchPolicy: {
+            rejections: policyRejections,
+            examples: policyExamples
+          }
+        } : {}
+      };
+    };
+  }
+});
+
+// src/lib/coreResearch/support.ts
+var init_support = __esm({
+  "src/lib/coreResearch/support.ts"() {
+    "use strict";
+    init_trace();
+  }
+});
+
 // src/lib/coreResearch/types.ts
 var CORE_RESEARCH_SCHEMA;
 var init_types = __esm({
@@ -48,15 +140,16 @@ var init_types = __esm({
 function assert(condition, message) {
   if (!condition) throw new Error(`Invalid core research spec: ${message}`);
 }
-var import_node_crypto, import_node_fs, import_promises, import_backtest, import_node_path, RESEARCH_ID_RE, SHA256_RE, canonicalJson, sha256Text, sha256Json, sha256File, assertFinite, validateCoreResearchSpec, loadCoreResearchSpec, writeJsonAtomic;
+var import_node_crypto, import_node_fs2, import_promises, import_backtest, import_node_path2, RESEARCH_ID_RE, SHA256_RE, canonicalJson, sha256Text, sha256Json, sha256File, assertFinite, validateCoreResearchSpec, loadCoreResearchSpec, writeJsonAtomic;
 var init_io = __esm({
   "src/lib/coreResearch/io.ts"() {
     "use strict";
     import_node_crypto = require("crypto");
-    import_node_fs = require("fs");
+    import_node_fs2 = require("fs");
     import_promises = __toESM(require("fs/promises"));
     import_backtest = require("@tradejs/core/backtest");
-    import_node_path = __toESM(require("path"));
+    import_node_path2 = __toESM(require("path"));
+    init_support();
     init_types();
     RESEARCH_ID_RE = /^[a-z0-9][a-z0-9._-]{2,120}$/;
     SHA256_RE = /^[a-f0-9]{64}$/;
@@ -75,10 +168,10 @@ var init_io = __esm({
     sha256Text = (value) => (0, import_node_crypto.createHash)("sha256").update(value).digest("hex");
     sha256Json = (value) => sha256Text(canonicalJson(value));
     sha256File = async (filePath) => {
-      const hash = (0, import_node_crypto.createHash)("sha256");
-      const input = (0, import_node_fs.createReadStream)(filePath);
-      for await (const chunk of input) hash.update(chunk);
-      return hash.digest("hex");
+      const hash2 = (0, import_node_crypto.createHash)("sha256");
+      const input = (0, import_node_fs2.createReadStream)(filePath);
+      for await (const chunk of input) hash2.update(chunk);
+      return hash2.digest("hex");
     };
     assertFinite = (value, name) => {
       assert(typeof value === "number" && Number.isFinite(value), name);
@@ -312,16 +405,32 @@ var init_io = __esm({
         Boolean(spec.artifacts?.ledgerPath?.trim()),
         "artifacts.ledgerPath is required"
       );
+      if (spec.support !== void 0) {
+        assert(
+          spec.support && typeof spec.support === "object",
+          "support must be an object"
+        );
+        for (const [key, value2] of [
+          ["minimumEvents", spec.support.minimumEvents],
+          ["minimumBlocks", spec.support.minimumBlocks],
+          ...spec.support.minimumCommonSetups === void 0 ? [] : [["minimumCommonSetups", spec.support.minimumCommonSetups]]
+        ]) {
+          assert(
+            typeof value2 === "number" && Number.isSafeInteger(value2) && value2 > 0,
+            `support.${key} must be a positive integer`
+          );
+        }
+      }
       return spec;
     };
     loadCoreResearchSpec = async (specPath) => {
-      const resolvedPath = import_node_path.default.resolve(specPath);
+      const resolvedPath = import_node_path2.default.resolve(specPath);
       const parsed = JSON.parse(await import_promises.default.readFile(resolvedPath, "utf8"));
       const spec = validateCoreResearchSpec(parsed);
       return { resolvedPath, spec, specSha256: sha256Json(spec) };
     };
     writeJsonAtomic = async (filePath, value) => {
-      await import_promises.default.mkdir(import_node_path.default.dirname(filePath), { recursive: true });
+      await import_promises.default.mkdir(import_node_path2.default.dirname(filePath), { recursive: true });
       const temporaryPath = `${filePath}.${process.pid}.${Date.now()}.tmp`;
       await import_promises.default.writeFile(temporaryPath, `${canonicalJson(value)}
 `, "utf8");
@@ -342,30 +451,30 @@ __export(io_exports, {
   verifyResearchState: () => verifyResearchState,
   withResearchLock: () => withResearchLock
 });
-var import_promises2, import_node_path2, import_node_os, import_node_crypto2, researchDirectory, readJson, boundResearchPath, withResearchLock, verifyResearchState, verifyCompletedResearch, initializeResearchState, isRetainedDeletion;
+var import_promises2, import_node_path3, import_node_os, import_node_crypto3, researchDirectory, readJson, boundResearchPath, withResearchLock, verifyResearchState, verifyCompletedResearch, initializeResearchState, isRetainedDeletion;
 var init_io2 = __esm({
   "src/lib/strategyResearch/io.ts"() {
     "use strict";
     import_promises2 = __toESM(require("fs/promises"));
-    import_node_path2 = __toESM(require("path"));
+    import_node_path3 = __toESM(require("path"));
     import_node_os = __toESM(require("os"));
-    import_node_crypto2 = require("crypto");
+    import_node_crypto3 = require("crypto");
     init_io();
-    researchDirectory = (projectRoot, spec) => import_node_path2.default.join(projectRoot, "data/research/strategy", spec.core.researchId);
+    researchDirectory = (projectRoot, spec) => import_node_path3.default.join(projectRoot, "data/research/strategy", spec.core.researchId);
     readJson = async (file) => JSON.parse(await import_promises2.default.readFile(file, "utf8"));
     boundResearchPath = async (root, relative) => {
-      const target = import_node_path2.default.resolve(root, relative);
+      const target = import_node_path3.default.resolve(root, relative);
       const realRoot = await import_promises2.default.realpath(root);
       let ancestor = target;
       while (true) {
         try {
           const real = await import_promises2.default.realpath(ancestor);
-          if (real !== realRoot && !real.startsWith(`${realRoot}${import_node_path2.default.sep}`))
+          if (real !== realRoot && !real.startsWith(`${realRoot}${import_node_path3.default.sep}`))
             throw new Error(`Research path escapes Project: ${relative}`);
           break;
         } catch (error) {
           if (error.code !== "ENOENT") throw error;
-          const parent = import_node_path2.default.dirname(ancestor);
+          const parent = import_node_path3.default.dirname(ancestor);
           if (parent === ancestor) throw error;
           ancestor = parent;
         }
@@ -377,8 +486,8 @@ var init_io2 = __esm({
         projectRoot,
         "data/research/strategy/.lock"
       );
-      await import_promises2.default.mkdir(import_node_path2.default.dirname(file), { recursive: true });
-      const token = (0, import_node_crypto2.randomUUID)();
+      await import_promises2.default.mkdir(import_node_path3.default.dirname(file), { recursive: true });
+      const token = (0, import_node_crypto3.randomUUID)();
       const acquire = () => import_promises2.default.writeFile(
         file,
         JSON.stringify({ pid: process.pid, host: import_node_os.default.hostname(), token }),
@@ -411,7 +520,7 @@ var init_io2 = __esm({
       }
     };
     verifyResearchState = async (directory, state) => {
-      const frozenSpec = await readJson(import_node_path2.default.join(directory, "spec.json"));
+      const frozenSpec = await readJson(import_node_path3.default.join(directory, "spec.json"));
       if (sha256Json(frozenSpec) !== state.specSha256)
         throw new Error("Frozen research spec changed");
       for (const [name, stage] of Object.entries(state.stages)) {
@@ -430,14 +539,14 @@ var init_io2 = __esm({
     };
     verifyCompletedResearch = async (directory, state) => {
       await verifyResearchState(directory, state);
-      const manifest = await readJson(import_node_path2.default.join(directory, "manifest.json"));
+      const manifest = await readJson(import_node_path3.default.join(directory, "manifest.json"));
       if (manifest.specSha256 !== state.specSha256)
         throw new Error("Final manifest spec mismatch");
       for (const [relative, expected] of Object.entries(manifest.artifacts))
         if (await sha256File(await boundResearchPath(directory, relative)) !== expected)
           throw new Error(`Changed final research artifact: ${relative}`);
-      const inventory = await readJson(import_node_path2.default.join(directory, "retention.json"));
-      const projectRoot = import_node_path2.default.resolve(directory, "../../../..");
+      const inventory = await readJson(import_node_path3.default.join(directory, "retention.json"));
+      const projectRoot = import_node_path3.default.resolve(directory, "../../../..");
       for (const artifact of inventory.research.permanentArtifacts) {
         const file = await boundResearchPath(projectRoot, artifact.path);
         if (await sha256File(file) !== artifact.sha256)
@@ -446,7 +555,7 @@ var init_io2 = __esm({
     };
     initializeResearchState = async (directory, spec, lineage) => {
       await import_promises2.default.mkdir(directory, { recursive: true });
-      const file = import_node_path2.default.join(directory, "state.json");
+      const file = import_node_path3.default.join(directory, "state.json");
       let previous;
       try {
         previous = await readJson(file);
@@ -470,19 +579,19 @@ var init_io2 = __esm({
         status: "running",
         stages: {}
       };
-      await writeJsonAtomic(import_node_path2.default.join(directory, "spec.json"), spec);
+      await writeJsonAtomic(import_node_path3.default.join(directory, "spec.json"), spec);
       await writeJsonAtomic(file, state);
       return state;
     };
-    isRetainedDeletion = async (directory, file, hash) => {
+    isRetainedDeletion = async (directory, file, hash2) => {
       try {
-        const inventory = await readJson(import_node_path2.default.join(directory, "retention.json"));
+        const inventory = await readJson(import_node_path3.default.join(directory, "retention.json"));
         const index = inventory.entries.findIndex(
-          (entry) => entry.path === file && entry.sha256 === hash
+          (entry) => entry.path === file && entry.sha256 === hash2
         );
         if (index < 0) return false;
-        const receipt = await readJson(import_node_path2.default.join(directory, "retention", `${index}.json`));
-        return ["applying", "completed"].includes(receipt.status) && receipt.files[0]?.path === file && receipt.files[0]?.sha256 === hash;
+        const receipt = await readJson(import_node_path3.default.join(directory, "retention", `${index}.json`));
+        return ["applying", "completed"].includes(receipt.status) && receipt.files[0]?.path === file && receipt.files[0]?.sha256 === hash2;
       } catch (error) {
         if (error.code === "ENOENT") return false;
         throw error;
@@ -504,6 +613,7 @@ var import_node_path16 = __toESM(require("path"));
 init_io();
 
 // src/lib/aiPocketSearch/features.ts
+var import_aiFeatures = require("@tradejs/core/aiFeatures");
 var DAY_MS = 24 * 60 * 60 * 1e3;
 var DAYS_PER_WEEK = 7;
 var DAYS_PER_MONTH = 30.4375;
@@ -872,15 +982,25 @@ var addFlattenedFeatures = ({
   value,
   segments,
   maxDepth,
-  shouldSkipPath = () => false
+  shouldSkipPath = () => false,
+  onFeatureExcluded
 }) => {
   if (!segments.length && !isPlainRecord(value)) {
     return;
   }
-  if (segments.length > maxDepth || isOutcomePath(segments) || shouldSkipPath(segments)) {
+  if (segments.length > maxDepth || isOutcomePath(segments)) {
+    onFeatureExcluded?.({
+      path: segments.join("."),
+      classification: segments.length > maxDepth ? "depth-limit" : "derived-policy"
+    });
     return;
   }
+  if (shouldSkipPath(segments)) return;
   if (Array.isArray(value)) {
+    onFeatureExcluded?.({
+      path: segments.join("."),
+      classification: "unprojected-array"
+    });
     return;
   }
   if (isFeaturePrimitive(value)) {
@@ -902,7 +1022,8 @@ var addFlattenedFeatures = ({
       value: child,
       segments: [...segments, key],
       maxDepth,
-      shouldSkipPath
+      shouldSkipPath,
+      onFeatureExcluded
     });
   }
 };
@@ -1114,7 +1235,10 @@ var collectAiPocketFeatureSnapshot = ({
     value: source,
     segments: [],
     maxDepth: 8,
+    onFeatureExcluded,
     shouldSkipPath: (segments) => {
+      if (segments.join(".") === "additionalIndicators.baseContext.tickerProfile" || segments.join(".") === "additionalIndicators.tickerProfile" || segments.join(".") === "additionalIndicators.portfolioContext")
+        return true;
       if (isOperatorExcluded(segments.join("."))) {
         return true;
       }
@@ -1132,6 +1256,10 @@ var collectAiPocketFeatureSnapshot = ({
         return true;
       }
       if (featureProfile === "compact" && isCompactFeaturePathSkipped(segments)) {
+        onFeatureExcluded?.({
+          path: segments.join("."),
+          classification: "compact-profile"
+        });
         return true;
       }
       if (featurePolicy !== "causal-stationary") {
@@ -1166,6 +1294,21 @@ var collectAiPocketFeatureSnapshot = ({
       delete features[key];
     }
   }
+  const registered = payload.featureSnapshot;
+  if (registered) {
+    (0, import_aiFeatures.validateAiFeatureSnapshot)(registered);
+    for (const definition of registered.definitions) {
+      const path17 = `registered.${definition.id}`;
+      if (isOperatorExcluded(path17)) continue;
+      const value = registered.values[definition.id];
+      const classification = definition.role === "outcome" || definition.role === "policy" ? "derived-policy" : definition.role !== "input" ? definition.role : featurePolicy === "causal-stationary" && !definition.stationary ? "raw-nonstationary" : value === null || value === "unknown" ? "data-quality" : "eligible";
+      if (classification !== "eligible") {
+        onFeatureExcluded?.({ path: path17, classification });
+        continue;
+      }
+      features[path17] = value;
+    }
+  }
   return { features, featureCoverage };
 };
 var collectAiPocketFeatures = (options) => collectAiPocketFeatureSnapshot(options).features;
@@ -1784,15 +1927,15 @@ var createPocketResult = (rows, predicates, mask, validationRows, testRows, obje
   };
 };
 var hashMask = (mask) => {
-  let hash = 2166136261;
+  let hash2 = 2166136261;
   for (let index = 0; index < mask.length; index += 1) {
     if (mask[index] !== 1) {
       continue;
     }
-    hash ^= index + 1;
-    hash = Math.imul(hash, 16777619);
+    hash2 ^= index + 1;
+    hash2 = Math.imul(hash2, 16777619);
   }
-  return (hash >>> 0).toString(36);
+  return (hash2 >>> 0).toString(36);
 };
 var isBetterRepresentativePocket = (candidate, existing, compare) => candidate.depth < existing.depth || candidate.depth === existing.depth && candidate.condition.length < existing.condition.length || candidate.depth === existing.depth && candidate.condition.length === existing.condition.length && compare(candidate, existing) < 0;
 var estimateCombinationCount = (poolSize, maxDepth, maxCombinations) => {
@@ -2489,7 +2632,52 @@ var policyVariant = (spec, coreId, policy, id, jev) => {
 
 // src/lib/strategyResearch/orchestrator.ts
 var import_promises5 = __toESM(require("fs/promises"));
-var import_node_path6 = __toESM(require("path"));
+
+// src/lib/researchMetricSnapshot.ts
+var import_node_crypto2 = require("crypto");
+var import_node_zlib = require("zlib");
+var MAX_BYTES = 256 * 1024 * 1024;
+var hash = (bytes) => (0, import_node_crypto2.createHash)("sha256").update(bytes).digest("hex");
+var validatePermanentResearchMetrics = (value) => {
+  if (!value || typeof value !== "object") return;
+  for (const [key, child] of Object.entries(value)) {
+    if (["matchedPairs", "tradeRows", "allProjectedLeaves"].includes(key) && Array.isArray(child) && child.length)
+      throw new Error(`Temporary payload ${key} is not a permanent metric`);
+    if (key === "trades" && Array.isArray(child) && child.some(
+      (row) => row && typeof row === "object" && ("signalId" in row || "entryTimestamp" in row)
+    ))
+      throw new Error("Temporary trade records are not permanent metrics");
+    validatePermanentResearchMetrics(child);
+  }
+};
+var encodeResearchMetricSnapshot = (metrics) => {
+  validatePermanentResearchMetrics(metrics);
+  const bytes = Buffer.from(JSON.stringify(metrics));
+  if (bytes.length > MAX_BYTES)
+    throw new Error("Metric snapshot exceeds decoded size limit");
+  return {
+    schema: "tradejs-metric-snapshot/v1",
+    encoding: "gzip+base64",
+    decodedBytes: bytes.length,
+    sha256: hash(bytes),
+    payload: (0, import_node_zlib.gzipSync)(bytes, { level: 9 }).toString("base64")
+  };
+};
+var decodeResearchMetricSnapshot = (snapshot) => {
+  if (!snapshot || typeof snapshot !== "object" || !("schema" in snapshot) || snapshot.schema !== "tradejs-metric-snapshot/v1" || !("encoding" in snapshot) || snapshot.encoding !== "gzip+base64" || !("decodedBytes" in snapshot) || typeof snapshot.decodedBytes !== "number" || !Number.isSafeInteger(snapshot.decodedBytes) || snapshot.decodedBytes <= 0 || snapshot.decodedBytes > MAX_BYTES || !("sha256" in snapshot) || typeof snapshot.sha256 !== "string" || !/^[a-f0-9]{64}$/.test(snapshot.sha256) || !("payload" in snapshot) || typeof snapshot.payload !== "string")
+    throw new Error("Invalid metric snapshot envelope");
+  const bytes = (0, import_node_zlib.gunzipSync)(Buffer.from(snapshot.payload, "base64"), {
+    maxOutputLength: snapshot.decodedBytes
+  });
+  if (bytes.length !== snapshot.decodedBytes || hash(bytes) !== snapshot.sha256)
+    throw new Error("Metric snapshot checksum or size mismatch");
+  const metrics = JSON.parse(bytes.toString("utf8"));
+  validatePermanentResearchMetrics(metrics);
+  return metrics;
+};
+
+// src/lib/strategyResearch/orchestrator.ts
+var import_node_path7 = __toESM(require("path"));
 
 // src/lib/coreResearch/metrics.ts
 var DAY_MS2 = 24 * 60 * 60 * 1e3;
@@ -3690,16 +3878,16 @@ var testCharts = (conclusion) => {
 
 // src/lib/strategyResearch/retention.ts
 var import_promises4 = __toESM(require("fs/promises"));
-var import_node_path5 = __toESM(require("path"));
+var import_node_path6 = __toESM(require("path"));
 
 // src/lib/strategyRelease/researchRetention.ts
 var import_promises3 = __toESM(require("fs/promises"));
-var import_node_path4 = __toESM(require("path"));
-var import_node_crypto3 = require("crypto");
+var import_node_path5 = __toESM(require("path"));
+var import_node_crypto4 = require("crypto");
 var import_strategyReleaseEvidence = require("@tradejs/infra/strategyReleaseEvidence");
 
 // src/lib/strategyRelease/researchFileConsumers.ts
-var import_node_path3 = __toESM(require("path"));
+var import_node_path4 = __toESM(require("path"));
 var import_node_child_process = require("child_process");
 var import_node_util = require("util");
 var execFileAsync = (0, import_node_util.promisify)(import_node_child_process.execFile);
@@ -3730,15 +3918,15 @@ print(json.dumps(sorted(opened)))
 `;
 var assertNoResearchFileConsumers = async (files, run = runCommand) => {
   const virtualPids = /* @__PURE__ */ new Set();
-  const wanted = new Set(files.map((file) => import_node_path3.default.resolve(file)));
-  let commonRoot = files.length ? import_node_path3.default.dirname(files[0]) : "";
+  const wanted = new Set(files.map((file) => import_node_path4.default.resolve(file)));
+  let commonRoot = files.length ? import_node_path4.default.dirname(files[0]) : "";
   while (commonRoot && files.some((file) => {
-    const relative = import_node_path3.default.relative(commonRoot, file);
-    return relative === ".." || relative.startsWith(`..${import_node_path3.default.sep}`) || import_node_path3.default.isAbsolute(relative);
+    const relative = import_node_path4.default.relative(commonRoot, file);
+    return relative === ".." || relative.startsWith(`..${import_node_path4.default.sep}`) || import_node_path4.default.isAbsolute(relative);
   }))
-    commonRoot = import_node_path3.default.dirname(commonRoot);
+    commonRoot = import_node_path4.default.dirname(commonRoot);
   const selectors = [];
-  if (files.length > 1e3 && commonRoot !== import_node_path3.default.parse(commonRoot).root) {
+  if (files.length > 1e3 && commonRoot !== import_node_path4.default.parse(commonRoot).root) {
     selectors.push(["+D", commonRoot]);
   } else {
     for (let offset = 0; offset < files.length; offset += 100)
@@ -3762,7 +3950,7 @@ var assertNoResearchFileConsumers = async (files, run = runCommand) => {
       if (line.startsWith("c"))
         virtual = line.startsWith("ccom.apple.Virtualization.");
       if (line.startsWith("n")) {
-        if (!wanted.has(import_node_path3.default.resolve(line.slice(1)))) continue;
+        if (!wanted.has(import_node_path4.default.resolve(line.slice(1)))) continue;
         if (!virtual || !/^\d+$/.test(pid))
           throw new Error(
             `Research cleanup found open files: ${line.slice(1)}`
@@ -3796,9 +3984,9 @@ var assertNoResearchFileConsumers = async (files, run = runCommand) => {
     for (const mount of container.Mounts) {
       if (mount.Type !== "bind") continue;
       for (const file of files) {
-        const relative = import_node_path3.default.relative(mount.Source, file);
-        if (relative === "" || !relative.startsWith(`..${import_node_path3.default.sep}`) && relative !== ".." && !import_node_path3.default.isAbsolute(relative)) {
-          guestFiles.add(import_node_path3.default.posix.join(mount.Destination, relative));
+        const relative = import_node_path4.default.relative(mount.Source, file);
+        if (relative === "" || !relative.startsWith(`..${import_node_path4.default.sep}`) && relative !== ".." && !import_node_path4.default.isAbsolute(relative)) {
+          guestFiles.add(import_node_path4.default.posix.join(mount.Destination, relative));
           covered.add(file);
         }
       }
@@ -3844,15 +4032,15 @@ var mapFiles = async (entries, visit) => {
     if (worker.status === "rejected") throw worker.reason;
   return results;
 };
-var fileSha256 = async (file, bytes) => bytes <= 1024 * 1024 ? (0, import_node_crypto3.createHash)("sha256").update(await import_promises3.default.readFile(file)).digest("hex") : (0, import_strategyReleaseEvidence.strategyEvidenceFileSha256)(file);
+var fileSha256 = async (file, bytes) => bytes <= 1024 * 1024 ? (0, import_node_crypto4.createHash)("sha256").update(await import_promises3.default.readFile(file)).digest("hex") : (0, import_strategyReleaseEvidence.strategyEvidenceFileSha256)(file);
 var inside = (root, file) => {
-  const relative = import_node_path4.default.relative(root, file);
-  return relative !== "" && !relative.startsWith(`..${import_node_path4.default.sep}`) && relative !== ".." && !import_node_path4.default.isAbsolute(relative);
+  const relative = import_node_path5.default.relative(root, file);
+  return relative !== "" && !relative.startsWith(`..${import_node_path5.default.sep}`) && relative !== ".." && !import_node_path5.default.isAbsolute(relative);
 };
 var applyResearchRetention = async (options) => {
   const projectRoot = await import_promises3.default.realpath(options.projectRoot);
-  const dataRoot = import_node_path4.default.join(projectRoot, "data");
-  const resolve = (file) => import_node_path4.default.resolve(projectRoot, file);
+  const dataRoot = import_node_path5.default.join(projectRoot, "data");
+  const resolve = (file) => import_node_path5.default.resolve(projectRoot, file);
   const receiptPath = resolve(options.receiptPath);
   const journalPath = `${receiptPath}.deleted.jsonl`;
   const permanent = new Set(
@@ -3888,13 +4076,27 @@ var applyResearchRetention = async (options) => {
         const header = Buffer.alloc(4096);
         const { bytesRead } = await handle.read(header, 0, header.length, 0);
         const frontmatter = header.subarray(0, bytesRead).toString("utf8").match(/^---\r?\n([\s\S]*?)\r?\n---/);
-        if (!frontmatter || !/^schema:\s*tradejs-research\/v1\s*$/m.test(frontmatter[1]) || !(retired ? /^reproduction:\s*(?:complete|partial|blocked|legacy-partial)\s*$/m.test(
+        if (!frontmatter || !/^schema:\s*tradejs-research\/v[12]\s*$/m.test(frontmatter[1]) || !(retired ? /^reproduction:\s*(?:complete|partial|blocked|legacy-partial)\s*$/m.test(
           frontmatter[1]
         ) : /^reproduction:\s*complete\s*$/m.test(frontmatter[1]))) {
           throw new Error(
             `Research note must have reproduction: complete: ${file}`
           );
         }
+        if (!retired && /^schema:\s*tradejs-research\/v2\s*$/m.test(frontmatter[1])) {
+          if ((await import_promises3.default.stat(file)).size > 8 * 1024 * 1024)
+            throw new Error("Compact permanent note exceeds 8 MiB");
+          const content = await import_promises3.default.readFile(file, "utf8");
+          const section = content.split("## Metrics snapshot (machine-readable)")[1]?.split("## Reported metrics")[0] ?? "";
+          const blocks = [
+            ...section.matchAll(/```json\r?\n([\s\S]*?)\r?\n```/g)
+          ];
+          if (blocks.length !== 1)
+            throw new Error(
+              "Complete v2 note needs one verified metric snapshot"
+            );
+          decodeResearchMetricSnapshot(JSON.parse(blocks[0][1]));
+        }
       } finally {
         await handle.close();
       }
@@ -3937,8 +4139,8 @@ var applyResearchRetention = async (options) => {
     }))
   };
   if (!options.apply) return receipt;
-  await import_promises3.default.mkdir(import_node_path4.default.dirname(receiptPath), { recursive: true });
-  if (await import_promises3.default.realpath(import_node_path4.default.dirname(receiptPath)) !== import_node_path4.default.dirname(receiptPath)) {
+  await import_promises3.default.mkdir(import_node_path5.default.dirname(receiptPath), { recursive: true });
+  if (await import_promises3.default.realpath(import_node_path5.default.dirname(receiptPath)) !== import_node_path5.default.dirname(receiptPath)) {
     throw new Error("Cleanup receipt refuses symlinked directories");
   }
   const lock = await import_promises3.default.open(`${receiptPath}.lock`, "wx");
@@ -3984,17 +4186,17 @@ var createResearchRetentionInventory = async (projectRoot, directory, spec, stat
   const permanentArtifacts = [];
   for (const [role, file] of [
     ["note", notePath],
-    ["metrics", import_node_path5.default.join(directory, "result.json")],
-    ["candidates", import_node_path5.default.join(directory, "03-freeze-gates/result.json")],
-    ["candidates", import_node_path5.default.join(directory, "resolved-spec.json")],
-    ["ledger", import_node_path5.default.join(directory, "05-freeze-primary/result.json")],
-    ["chart", import_node_path5.default.join(directory, "report.html")],
+    ["metrics", import_node_path6.default.join(directory, "result.json")],
+    ["candidates", import_node_path6.default.join(directory, "03-freeze-gates/result.json")],
+    ["candidates", import_node_path6.default.join(directory, "resolved-spec.json")],
+    ["ledger", import_node_path6.default.join(directory, "05-freeze-primary/result.json")],
+    ["chart", import_node_path6.default.join(directory, "report.html")],
     ...[
       "source.patch",
       "source-baseline.tar",
       "source-untracked.json",
       "source-jev-models.json"
-    ].map((file2) => ["source", import_node_path5.default.join(directory, file2)])
+    ].map((file2) => ["source", import_node_path6.default.join(directory, file2)])
   ]) {
     try {
       permanentArtifacts.push({
@@ -4008,11 +4210,11 @@ var createResearchRetentionInventory = async (projectRoot, directory, spec, stat
   }
   const files = /* @__PURE__ */ new Map();
   for (const stage of Object.values(state.stages)) {
-    for (const [relative, hash] of Object.entries(stage.artifacts)) {
+    for (const [relative, hash2] of Object.entries(stage.artifacts)) {
       const file = await boundResearchPath(directory, relative);
       if (relative.endsWith("/result.json")) {
         const result = await readJson(file);
-        if (result?.dataset) files.set(file, hash);
+        if (result?.dataset) files.set(file, hash2);
       }
       if (relative.endsWith("/sources.json") || relative.endsWith("/payloads.json")) {
         const sources = await readJson(file);
@@ -4029,13 +4231,13 @@ var createResearchRetentionInventory = async (projectRoot, directory, spec, stat
     }
   }
   const entries = [];
-  for (const [file, hash] of files) {
+  for (const [file, hash2] of files) {
     const stat = await import_promises4.default.stat(file);
     entries.push({
       path: file,
       kind: "research_payload",
       researchId: spec.core.researchId,
-      sha256: hash,
+      sha256: hash2,
       bytes: stat.size,
       createdAt: stat.birthtimeMs,
       verified: true,
@@ -4054,13 +4256,13 @@ var createResearchRetentionInventory = async (projectRoot, directory, spec, stat
 };
 var applyRetentionInventory = async (projectRoot, directory) => {
   const inventory = await readJson(
-    import_node_path5.default.join(directory, "retention.json")
+    import_node_path6.default.join(directory, "retention.json")
   );
-  const receipts = import_node_path5.default.join(directory, "retention");
+  const receipts = import_node_path6.default.join(directory, "retention");
   await import_promises4.default.mkdir(receipts, { recursive: true });
   for (let index = 0; index < inventory.entries.length; index++) {
     const entry = inventory.entries[index];
-    const receiptPath = import_node_path5.default.join(receipts, `${index}.json`);
+    const receiptPath = import_node_path6.default.join(receipts, `${index}.json`);
     let receipt;
     try {
       receipt = await readJson(receiptPath);
@@ -4096,13 +4298,13 @@ var applyRetentionInventory = async (projectRoot, directory) => {
       entries: [entry],
       receiptPath,
       apply: true,
-      protectedPaths: [import_node_path5.default.join(directory, "retention.json")]
+      protectedPaths: [import_node_path6.default.join(directory, "retention.json")]
     });
   }
   return { status: "completed", files: inventory.entries.length };
 };
 var finishResearchRetention = async (projectRoot, directory) => {
-  const statusPath = import_node_path5.default.join(directory, "retention-status.json");
+  const statusPath = import_node_path6.default.join(directory, "retention-status.json");
   try {
     const result = await applyRetentionInventory(projectRoot, directory);
     await writeJsonAtomic(statusPath, result);
@@ -4129,7 +4331,7 @@ var runStrategyResearch = async (parameters) => {
     const directory = researchDirectory(projectRoot, spec);
     const lineage = await backend.lineage();
     const state = await initializeResearchState(directory, spec, lineage);
-    const statePath = import_node_path6.default.join(directory, "state.json");
+    const statePath = import_node_path7.default.join(directory, "state.json");
     const elapsedBefore = state.elapsedMs ?? 0;
     const activeStart = Date.now();
     const elapsed = () => elapsedBefore + Date.now() - activeStart;
@@ -4139,7 +4341,7 @@ var runStrategyResearch = async (parameters) => {
         directory,
         state,
         conclusion: await readJson(
-          import_node_path6.default.join(directory, "result.json")
+          import_node_path7.default.join(directory, "result.json")
         )
       };
     }
@@ -4149,13 +4351,13 @@ var runStrategyResearch = async (parameters) => {
       return writeJsonAtomic(statePath, state);
     };
     const event = async (stage2, status) => import_promises5.default.appendFile(
-      import_node_path6.default.join(directory, "events.jsonl"),
+      import_node_path7.default.join(directory, "events.jsonl"),
       `${JSON.stringify({ at: (/* @__PURE__ */ new Date()).toISOString(), stage: stage2, status, specSha256: state.specSha256 })}
 `
     );
     const stage = async (name, work) => {
       const stageDirectory = await boundResearchPath(directory, name);
-      const resultPath = import_node_path6.default.join(stageDirectory, "result.json");
+      const resultPath = import_node_path7.default.join(stageDirectory, "result.json");
       if (state.stages[name]?.status === "completed")
         return readJson(resultPath);
       if (elapsed() > spec.budget.maxMinutes * 6e4)
@@ -4174,7 +4376,7 @@ var runStrategyResearch = async (parameters) => {
       await save();
       await event(name, "started");
       await import_promises5.default.writeFile(
-        import_node_path6.default.join(directory, "report.html"),
+        import_node_path7.default.join(directory, "report.html"),
         buildStrategyResearchReport({ spec, state, diagnostics })
       );
       try {
@@ -4182,7 +4384,7 @@ var runStrategyResearch = async (parameters) => {
         await writeJsonAtomic(resultPath, result);
         const artifacts = {};
         for (const file of await import_promises5.default.readdir(stageDirectory)) {
-          const full = import_node_path6.default.join(stageDirectory, file);
+          const full = import_node_path7.default.join(stageDirectory, file);
           if ((await import_promises5.default.stat(full)).isFile())
             artifacts[`${name}/${file}`] = await sha256File(full);
         }
@@ -4194,7 +4396,7 @@ var runStrategyResearch = async (parameters) => {
             "source-jev-models.json"
           ]) {
             try {
-              artifacts[file] = await sha256File(import_node_path6.default.join(directory, file));
+              artifacts[file] = await sha256File(import_node_path7.default.join(directory, file));
             } catch (error) {
               if (error.code !== "ENOENT")
                 throw error;
@@ -4227,14 +4429,14 @@ var runStrategyResearch = async (parameters) => {
       let previousRunId;
       try {
         previousRunId = (await readJson(
-          import_node_path6.default.join(folder, "native-run.json")
+          import_node_path7.default.join(folder, "native-run.json")
         )).runId;
       } catch (error) {
         if (error.code !== "ENOENT") throw error;
       }
       if (!previousRunId) {
         try {
-          if ((await import_promises5.default.stat(import_node_path6.default.join(folder, "backtest.log"))).size)
+          if ((await import_promises5.default.stat(import_node_path7.default.join(folder, "backtest.log"))).size)
             throw new Error(
               "Previous native attempt has no recorded run identity; inspect its log before another launch"
             );
@@ -4255,7 +4457,7 @@ var runStrategyResearch = async (parameters) => {
         },
         variant,
         folder,
-        async (runId) => writeJsonAtomic(import_node_path6.default.join(folder, "native-run.json"), { runId }),
+        async (runId) => writeJsonAtomic(import_node_path7.default.join(folder, "native-run.json"), { runId }),
         previousRunId,
         confirmation
       );
@@ -4270,15 +4472,15 @@ var runStrategyResearch = async (parameters) => {
     try {
       const inventory = await stage("01-preflight", async () => {
         const prior = [];
-        const root = import_node_path6.default.dirname(directory);
+        const root = import_node_path7.default.dirname(directory);
         for (const id of await import_promises5.default.readdir(root)) {
           if (id === spec.core.researchId || id.startsWith(".")) continue;
           try {
             const previous = await readJson(
-              import_node_path6.default.join(root, id, "spec.json")
+              import_node_path7.default.join(root, id, "spec.json")
             );
             const previousState = await readJson(
-              import_node_path6.default.join(root, id, "state.json")
+              import_node_path7.default.join(root, id, "state.json")
             );
             const overlap = previous.core.strategy === spec.core.strategy && previous.core.window.start < spec.core.window.end && previous.core.window.end > (spec.testSince || spec.core.window.start);
             if (overlap && previousState.holdoutOpenedAt)
@@ -4304,7 +4506,7 @@ var runStrategyResearch = async (parameters) => {
             let previous;
             try {
               previous = (await readJson(
-                import_node_path6.default.join(folder, "native-run.json")
+                import_node_path7.default.join(folder, "native-run.json")
               )).runId;
             } catch (error) {
               if (error.code !== "ENOENT")
@@ -4314,7 +4516,7 @@ var runStrategyResearch = async (parameters) => {
               spec,
               control2,
               folder,
-              async (runId) => writeJsonAtomic(import_node_path6.default.join(folder, "native-run.json"), {
+              async (runId) => writeJsonAtomic(import_node_path7.default.join(folder, "native-run.json"), {
                 runId
               }),
               previous
@@ -4328,7 +4530,7 @@ var runStrategyResearch = async (parameters) => {
         );
         spec = { ...spec, testSince: partition.testSince };
       }
-      await writeJsonAtomic(import_node_path6.default.join(directory, "resolved-spec.json"), spec);
+      await writeJsonAtomic(import_node_path7.default.join(directory, "resolved-spec.json"), spec);
       let gates = [];
       let primaryId = null;
       let frozenSelection;
@@ -4387,10 +4589,10 @@ var runStrategyResearch = async (parameters) => {
           core: { ...spec.core, researchId: spec.frozenFrom }
         });
         const parentState = await readJson(
-          import_node_path6.default.join(parentDirectory, "state.json")
+          import_node_path7.default.join(parentDirectory, "state.json")
         );
         const parentSpec = await readJson(
-          import_node_path6.default.join(parentDirectory, "spec.json")
+          import_node_path7.default.join(parentDirectory, "spec.json")
         );
         const { verifyCompletedResearch: verifyCompletedResearch2 } = await Promise.resolve().then(() => (init_io2(), io_exports));
         await verifyCompletedResearch2(parentDirectory, parentState);
@@ -4417,10 +4619,10 @@ var runStrategyResearch = async (parameters) => {
             "Frozen revalidation requires complete, unchanged rules/runtime and a strictly new period"
           );
         gates = await readJson(
-          import_node_path6.default.join(parentDirectory, "03-freeze-gates/result.json")
+          import_node_path7.default.join(parentDirectory, "03-freeze-gates/result.json")
         );
         frozenSelection = await readJson(
-          import_node_path6.default.join(parentDirectory, "05-freeze-primary/result.json")
+          import_node_path7.default.join(parentDirectory, "05-freeze-primary/result.json")
         );
         if (frozenSelection.schema !== "tradejs-research-selection/v1" || !Array.isArray(frozenSelection.compositions))
           throw new Error(
@@ -4549,7 +4751,7 @@ var runStrategyResearch = async (parameters) => {
           `06-raw-metrics-${variant.id}`,
           async (folder) => {
             const resolved = spec.frozenFrom ? (await run(spec, variant, `06-raw-revalidation-${variant.id}`)).variant : (await readJson(
-              import_node_path6.default.join(directory, `02-raw-${variant.id}`, "result.json")
+              import_node_path7.default.join(directory, `02-raw-${variant.id}`, "result.json")
             )).variant;
             const dataset = await backend.loadDataset(
               spec,
@@ -4726,7 +4928,7 @@ var runStrategyResearch = async (parameters) => {
       for (const name of Object.keys(state.stages)) {
         try {
           const result = await readJson(
-            import_node_path6.default.join(directory, name, "result.json")
+            import_node_path7.default.join(directory, name, "result.json")
           );
           if (result?.variant)
             executions.push({ stage: name, ...result.variant });
@@ -4734,7 +4936,7 @@ var runStrategyResearch = async (parameters) => {
           if (error.code !== "ENOENT") throw error;
         }
       }
-      await writeJsonAtomic(import_node_path6.default.join(directory, "result.json"), {
+      await writeJsonAtomic(import_node_path7.default.join(directory, "result.json"), {
         ...conclusion,
         executions,
         rawCore: Object.entries(rawReports).map(([id, windows]) => ({
@@ -4748,7 +4950,7 @@ var runStrategyResearch = async (parameters) => {
       delete state.error;
       await save();
       await import_promises5.default.writeFile(
-        import_node_path6.default.join(directory, "report.html"),
+        import_node_path7.default.join(directory, "report.html"),
         buildStrategyResearchReport({
           spec,
           state,
@@ -4779,7 +4981,7 @@ var runStrategyResearch = async (parameters) => {
         )
       };
       const note = `---
-schema: tradejs-research/v1
+schema: tradejs-research/v2
 strategy: '${spec.core.strategy}'
 date: '${spec.core.createdAt.slice(0, 10)}'
 kind: 'backtest'
@@ -4812,7 +5014,7 @@ ${JSON.stringify(spec, null, 2)}
 ## Metrics snapshot (machine-readable)
 
 \`\`\`json
-${JSON.stringify(compact, null, 2)}
+${JSON.stringify(encodeResearchMetricSnapshot(compact))}
 \`\`\`
 
 ## Reported metrics
@@ -4831,8 +5033,12 @@ ${directory}/report.html
 
 ${conclusion.nextAction} Current-snapshot universe; no deployment authorization. Temporary payloads are deleted only after the permanent record is verified; new trade-level questions require a frozen rerun.
 `;
+      if (Buffer.byteLength(note) > 8 * 1024 * 1024)
+        throw new Error(
+          "Compact permanent note exceeds 8 MiB; archive source separately, never truncate metrics"
+        );
       await import_promises5.default.writeFile(
-        import_node_path6.default.join(
+        import_node_path7.default.join(
           noteDirectory,
           `${spec.core.createdAt.slice(0, 10)}-${spec.core.researchId}.md`
         ),
@@ -4841,7 +5047,7 @@ ${conclusion.nextAction} Current-snapshot universe; no deployment authorization.
       ).catch(async (error) => {
         if (error.code !== "EEXIST") throw error;
         const existing = await import_promises5.default.readFile(
-          import_node_path6.default.join(
+          import_node_path7.default.join(
             noteDirectory,
             `${spec.core.createdAt.slice(0, 10)}-${spec.core.researchId}.md`
           ),
@@ -4853,19 +5059,19 @@ ${conclusion.nextAction} Current-snapshot universe; no deployment authorization.
           );
       });
       await writeJsonAtomic(
-        import_node_path6.default.join(directory, "retention.json"),
+        import_node_path7.default.join(directory, "retention.json"),
         await createResearchRetentionInventory(
           projectRoot,
           directory,
           spec,
           state,
-          import_node_path6.default.join(
+          import_node_path7.default.join(
             noteDirectory,
             `${spec.core.createdAt.slice(0, 10)}-${spec.core.researchId}.md`
           )
         )
       );
-      await writeJsonAtomic(import_node_path6.default.join(directory, "manifest.json"), {
+      await writeJsonAtomic(import_node_path7.default.join(directory, "manifest.json"), {
         schema: "tradejs-strategy-research-manifest/v1",
         specSha256: state.specSha256,
         artifacts: Object.fromEntries(
@@ -4879,7 +5085,7 @@ ${conclusion.nextAction} Current-snapshot universe; no deployment authorization.
               "retention.json"
             ].map(async (file) => [
               file,
-              await sha256File(import_node_path6.default.join(directory, file))
+              await sha256File(import_node_path7.default.join(directory, file))
             ])
           )
         )
@@ -4892,7 +5098,7 @@ ${conclusion.nextAction} Current-snapshot universe; no deployment authorization.
         );
       }
       parameters.onProgress?.(
-        `\u0418\u0442\u043E\u0433: ${conclusion.status}. \u041E\u0442\u0447\u0451\u0442: ${import_node_path6.default.join(directory, "report.html")}`
+        `\u0418\u0442\u043E\u0433: ${conclusion.status}. \u041E\u0442\u0447\u0451\u0442: ${import_node_path7.default.join(directory, "report.html")}`
       );
       return { directory, state, conclusion };
     } catch (error) {
@@ -4913,9 +5119,9 @@ ${conclusion.nextAction} Current-snapshot universe; no deployment authorization.
           frozenGates: 0
         }
       };
-      await writeJsonAtomic(import_node_path6.default.join(directory, "result.json"), conclusion);
+      await writeJsonAtomic(import_node_path7.default.join(directory, "result.json"), conclusion);
       await import_promises5.default.writeFile(
-        import_node_path6.default.join(directory, "report.html"),
+        import_node_path7.default.join(directory, "report.html"),
         buildStrategyResearchReport({ spec, state, conclusion, diagnostics })
       );
       throw error;
@@ -4938,10 +5144,10 @@ var import_registry = require("@tradejs/node/registry");
 var import_connectors = require("@tradejs/node/connectors");
 
 // src/lib/coreResearch/dataset.ts
-var import_node_crypto4 = require("crypto");
-var import_node_fs2 = require("fs");
-var import_node_path7 = __toESM(require("path"));
-var import_node_readline = __toESM(require("readline"));
+var import_node_crypto5 = require("crypto");
+var import_node_fs3 = require("fs");
+var import_node_path8 = __toESM(require("path"));
+var import_node_readline2 = __toESM(require("readline"));
 var asRecord = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : null;
 var finiteNumber = (value, field) => {
   const numeric = Number(value);
@@ -5151,11 +5357,11 @@ var readCoreResearchVariant = async (variant) => {
   const seen = /* @__PURE__ */ new Map();
   let duplicateRowsDropped = 0;
   for (const inputPath of variant.files) {
-    const filePath = import_node_path7.default.resolve(inputPath);
-    const input = (0, import_node_fs2.createReadStream)(filePath);
-    const hash = (0, import_node_crypto4.createHash)("sha256");
-    input.on("data", (chunk) => hash.update(chunk));
-    const lines = import_node_readline.default.createInterface({ input, crlfDelay: Infinity });
+    const filePath = import_node_path8.default.resolve(inputPath);
+    const input = (0, import_node_fs3.createReadStream)(filePath);
+    const hash2 = (0, import_node_crypto5.createHash)("sha256");
+    input.on("data", (chunk) => hash2.update(chunk));
+    const lines = import_node_readline2.default.createInterface({ input, crlfDelay: Infinity });
     const fileTrades = [];
     let lineNumber = 0;
     let rows = 0;
@@ -5204,7 +5410,7 @@ var readCoreResearchVariant = async (variant) => {
       trades.push(trade);
       fileTrades.push(trade);
     }
-    const fileSha2562 = hash.digest("hex");
+    const fileSha2562 = hash2.digest("hex");
     for (const trade of fileTrades) trade.sourceSha256 = fileSha2562;
     sources.push({
       path: filePath,
@@ -5224,7 +5430,7 @@ var readCoreResearchVariant = async (variant) => {
 };
 
 // src/lib/backtest/checkpoint.ts
-var import_node_crypto5 = require("crypto");
+var import_node_crypto6 = require("crypto");
 var import_constants = require("@tradejs/core/constants");
 var import_backtest2 = require("@tradejs/core/backtest");
 var import_redis = require("@tradejs/infra/redis");
@@ -5424,6 +5630,7 @@ var extractSignalFromAiDatasetRow = (row) => {
   const { payload } = row;
   return {
     ...payload.signal,
+    aiFeatureReplay: { snapshot: payload.featureSnapshot ?? null },
     strategy: payload.signal.strategy,
     figures: payload.figures ?? {},
     indicators: payload.indicators ?? {},
@@ -5437,9 +5644,9 @@ init_io2();
 
 // src/lib/aiTrainResearch.ts
 var import_node_child_process2 = require("child_process");
-var import_node_crypto7 = require("crypto");
+var import_node_crypto8 = require("crypto");
 var import_promises7 = __toESM(require("fs/promises"));
-var import_node_path9 = __toESM(require("path"));
+var import_node_path10 = __toESM(require("path"));
 
 // src/lib/aiTrainMetrics.ts
 var DAY_MS3 = 24 * 60 * 60 * 1e3;
@@ -5449,10 +5656,10 @@ var import_strategies = require("@tradejs/node/strategies");
 var import_types2 = require("@tradejs/types");
 
 // src/lib/strategyGateFingerprint.ts
-var import_node_crypto6 = require("crypto");
+var import_node_crypto7 = require("crypto");
 var import_node_module = require("module");
 var import_promises6 = __toESM(require("fs/promises"));
-var import_node_path8 = __toESM(require("path"));
+var import_node_path9 = __toESM(require("path"));
 
 // src/lib/aiTrainResearch.ts
 var DAY_MS4 = 24 * 60 * 60 * 1e3;
@@ -5462,6 +5669,8 @@ var RESEARCH_CONTEXT_ENV_KEYS = [
   "INTERVAL",
   "DERIVATIVES_CONTEXT_ENABLED",
   "DERIVATIVES_CONTEXT_TARGET_ENABLED",
+  "TICKER_PROFILES_PROVIDER",
+  "TICKER_PROFILES_UNIVERSE",
   "DERIVATIVES_CONTEXT_LOOKBACK_HOURS",
   "DERIVATIVES_CONTEXT_EXTRA_REFERENCE_SYMBOLS",
   "DERIVATIVES_CONTEXT_EXCHANGE_PRIORITY",
@@ -5491,7 +5700,7 @@ var normalizeForStableJson = (value) => {
   }
   return value;
 };
-var fingerprintResearchValue = (value) => (0, import_node_crypto7.createHash)("sha256").update(JSON.stringify(normalizeForStableJson(value))).digest("hex").slice(0, 16);
+var fingerprintResearchValue = (value) => (0, import_node_crypto8.createHash)("sha256").update(JSON.stringify(normalizeForStableJson(value))).digest("hex").slice(0, 16);
 var fingerprintResearchContextEnvironment = (env = process.env) => fingerprintResearchValue(
   Object.fromEntries(
     RESEARCH_CONTEXT_ENV_KEYS.map((key) => [key, env[key] ?? null])
@@ -5501,81 +5710,7 @@ var fingerprintResearchContextEnvironment = (env = process.env) => fingerprintRe
 // src/lib/strategyResearch/native.ts
 var import_data = require("@tradejs/core/data");
 var import_coreResearch = require("@tradejs/infra/coreResearch");
-
-// src/lib/coreResearch/trace.ts
-var import_node_fs3 = require("fs");
-var import_node_readline2 = __toESM(require("readline"));
-var import_node_path10 = __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_path10.default.resolve(inputPath);
-    const input = (0, import_node_fs3.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
-            });
-        }
-      }
-    } finally {
-      lines.close();
-      input.destroy();
-    }
-  }
-  return {
-    events: Object.fromEntries(Object.entries(events).sort()),
-    skipCounts: Object.fromEntries(
-      Object.entries(skipCounts).sort(
-        ([leftKey, leftValue], [rightKey, rightValue]) => rightValue - leftValue || (leftKey < rightKey ? -1 : leftKey > rightKey ? 1 : 0)
-      )
-    ),
-    exitCodes: Object.fromEntries(
-      Object.entries(exitCodes).sort(
-        ([leftKey, leftValue], [rightKey, rightValue]) => rightValue - leftValue || (leftKey < rightKey ? -1 : leftKey > rightKey ? 1 : 0)
-      )
-    ),
-    ...policyExamples.length ? {
-      researchPolicy: {
-        rejections: policyRejections,
-        examples: policyExamples
-      }
-    } : {}
-  };
-};
-
-// src/lib/strategyResearch/native.ts
+init_trace();
 var import_jev4 = require("@tradejs/core/jev");
 
 // src/lib/backtest/jevOptions.ts
@@ -6532,7 +6667,7 @@ init_io();
 var import_promises11 = __toESM(require("fs/promises"));
 var import_node_path15 = __toESM(require("path"));
 var import_node_child_process4 = require("child_process");
-var import_node_crypto9 = require("crypto");
+var import_node_crypto10 = require("crypto");
 var import_coreResearch2 = require("@tradejs/infra/coreResearch");
 
 // src/lib/coreResearch/artifacts.ts
@@ -6546,9 +6681,10 @@ init_io();
 init_io();
 
 // src/lib/coreResearch/statistics.ts
-var import_node_crypto8 = require("crypto");
+var import_node_crypto9 = require("crypto");
 
 // src/lib/coreResearch/orchestrator.ts
+init_trace();
 init_types();
 var createCoreResearchSpecTemplate = (params) => {
   const rootDir = import_node_path15.default.relative(
@@ -6584,7 +6720,7 @@ var createCoreResearchSpecTemplate = (params) => {
         gitSha,
         ...sourceRepository ? { sourceRepository } : {},
         ...dirtyDiff ? {
-          dirtyDiffSha256: (0, import_node_crypto9.createHash)("sha256").update(dirtyDiff).digest("hex")
+          dirtyDiffSha256: (0, import_node_crypto10.createHash)("sha256").update(dirtyDiff).digest("hex")
         } : {}
       };
     } catch {