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

package/dist/scripts/coreResearch.js

@@ -39,10 +39,161 @@ var import_chalk = __toESM(require("chalk"));
 
 // src/lib/coreResearch/io.ts
 var import_node_crypto = require("crypto");
-var import_node_fs = require("fs");
+var import_node_fs2 = require("fs");
 var import_promises = __toESM(require("fs/promises"));
 var import_backtest = require("@tradejs/core/backtest");
+var import_node_path2 = __toESM(require("path"));
+
+// src/lib/coreResearch/trace.ts
+var import_node_fs = require("fs");
+var import_node_readline = __toESM(require("readline"));
 var import_node_path = __toESM(require("path"));
+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 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
+async function assessCoreResearchSupport(spec, criteria) {
+  const symbols = new Set(spec.universe.symbols);
+  const blockMs = spec.robustness.clusterDays * 864e5;
+  const variants = [];
+  for (const variant of spec.variants) {
+    if (!variant.traceFiles?.length) continue;
+    const setups = /* @__PURE__ */ new Set();
+    const timestamps = /* @__PURE__ */ new Set();
+    const blocks = /* @__PURE__ */ new Map();
+    const seenSymbols = /* @__PURE__ */ new Set();
+    const runs = /* @__PURE__ */ new Set();
+    let fallbackRows = 0;
+    for await (const event of readCoreResearchTrace(variant.traceFiles)) {
+      if (variant.runId && event.backtestRunId !== variant.runId) continue;
+      runs.add(event.backtestRunId);
+      if (event.event !== "signal_emitted" && event.event !== "entry_rejected" || event.strategy !== spec.strategy || !symbols.has(event.symbol) || spec.hypothesis.target !== "ALL" && event.direction !== spec.hypothesis.target || !Number.isSafeInteger(event.timestamp) || event.timestamp < spec.window.start || event.timestamp >= spec.window.end)
+        continue;
+      timestamps.add(event.timestamp);
+      seenSymbols.add(event.symbol);
+      if (event.setupIdentitySource === "strategy-context" && event.setupIdentity) {
+        setups.add(
+          JSON.stringify([event.symbol, event.direction, event.setupIdentity])
+        );
+      } else fallbackRows++;
+      const block = Math.floor((event.timestamp - spec.window.start) / blockMs);
+      const times = blocks.get(block) ?? /* @__PURE__ */ new Set();
+      times.add(event.timestamp);
+      blocks.set(block, times);
+    }
+    if (runs.size > 1)
+      throw new Error(`Support traces mix runs for ${variant.id}`);
+    variants.push({
+      id: variant.id,
+      role: variant.role,
+      setups,
+      events: timestamps.size,
+      symbols: seenSymbols.size,
+      fallbackRows,
+      blocks: [...blocks].sort(([a], [b]) => a - b).map(([index, times]) => ({
+        start: spec.window.start + index * blockMs,
+        events: times.size
+      })),
+      passed: timestamps.size >= criteria.minimumEvents && blocks.size >= criteria.minimumBlocks
+    });
+  }
+  const control = variants.find((v) => v.role === "control");
+  const candidates = variants.filter((v) => v.role === "candidate");
+  const comparisons = control ? candidates.map((candidate) => ({
+    candidate: candidate.id,
+    commonSetups: [...candidate.setups].filter(
+      (id) => control.setups.has(id)
+    ).length
+  })) : [];
+  const missing = !control || criteria.minimumCommonSetups !== void 0 && candidates.length !== spec.variants.filter((v) => v.role === "candidate").length;
+  const insufficient = variants.some((v) => !v.passed) || comparisons.some(
+    (c) => c.commonSetups < (criteria.minimumCommonSetups ?? 0)
+  );
+  return {
+    schema: "tradejs-core-research-support/v1",
+    window: { start: spec.window.start, end: spec.window.end },
+    target: spec.hypothesis.target,
+    blockDays: spec.robustness.clusterDays,
+    criteria,
+    status: missing ? "missing-evidence" : insufficient ? "insufficient-support" : "supported",
+    variants: variants.map(({ setups, ...variant }) => ({
+      ...variant,
+      explicitSetups: setups.size
+    })),
+    comparisons
+  };
+}
 
 // src/lib/coreResearch/types.ts
 var CORE_RESEARCH_SCHEMA = "tradejs-core-research/v1";
@@ -68,7 +219,7 @@ var sha256Text = (value) => (0, import_node_crypto.createHash)("sha256").update(
 var sha256Json = (value) => sha256Text(canonicalJson(value));
 var sha256File = async (filePath) => {
   const hash = (0, import_node_crypto.createHash)("sha256");
-  const input = (0, import_node_fs.createReadStream)(filePath);
+  const input = (0, import_node_fs2.createReadStream)(filePath);
   for await (const chunk of input) hash.update(chunk);
   return hash.digest("hex");
 };
@@ -307,33 +458,49 @@ var validateCoreResearchSpec = (value) => {
     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;
 };
 var 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) };
 };
 var resolveCoreResearchPaths = (spec) => {
-  const rootDir = import_node_path.default.resolve(spec.artifacts.rootDir);
-  const researchDir = import_node_path.default.join(rootDir, spec.researchId);
+  const rootDir = import_node_path2.default.resolve(spec.artifacts.rootDir);
+  const researchDir = import_node_path2.default.join(rootDir, spec.researchId);
   return {
     rootDir,
     researchDir,
-    ledgerPath: import_node_path.default.resolve(spec.artifacts.ledgerPath),
-    specPath: import_node_path.default.join(researchDir, "spec.json"),
-    manifestPath: import_node_path.default.join(researchDir, "manifest.json"),
-    resultPath: import_node_path.default.join(researchDir, "result.json"),
-    comparisonPath: import_node_path.default.join(researchDir, "comparison.json"),
-    matchesPath: import_node_path.default.join(researchDir, "matches.csv"),
-    tradesPath: import_node_path.default.join(researchDir, "trades.jsonl"),
-    reportPath: import_node_path.default.join(researchDir, "report.html"),
-    runLogDir: import_node_path.default.join(researchDir, "runs")
+    ledgerPath: import_node_path2.default.resolve(spec.artifacts.ledgerPath),
+    specPath: import_node_path2.default.join(researchDir, "spec.json"),
+    manifestPath: import_node_path2.default.join(researchDir, "manifest.json"),
+    resultPath: import_node_path2.default.join(researchDir, "result.json"),
+    comparisonPath: import_node_path2.default.join(researchDir, "comparison.json"),
+    matchesPath: import_node_path2.default.join(researchDir, "matches.csv"),
+    tradesPath: import_node_path2.default.join(researchDir, "trades.jsonl"),
+    reportPath: import_node_path2.default.join(researchDir, "report.html"),
+    runLogDir: import_node_path2.default.join(researchDir, "runs")
   };
 };
 var 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");
@@ -380,7 +547,7 @@ var verifyCoreResearchLedger = (records) => {
 };
 var appendCoreResearchLedger = async (params) => {
   const { ledgerPath } = params;
-  await import_promises.default.mkdir(import_node_path.default.dirname(ledgerPath), { recursive: true });
+  await import_promises.default.mkdir(import_node_path2.default.dirname(ledgerPath), { recursive: true });
   const lockPath = `${ledgerPath}.lock`;
   let lock = null;
   try {
@@ -419,14 +586,14 @@ var appendCoreResearchLedger = async (params) => {
 var validateCoreResearchParentLineage = async (spec) => {
   if (spec.stage === "screen") return;
   const expectedParentStage = spec.stage === "isolated_long" ? "screen" : "isolated_long";
-  const rootDir = import_node_path.default.resolve(spec.artifacts.rootDir);
+  const rootDir = import_node_path2.default.resolve(spec.artifacts.rootDir);
   const passedParentCandidateConfigShas = /* @__PURE__ */ new Set();
   for (const parentResearchId of spec.parentResearchIds ?? []) {
-    const parentDir = import_node_path.default.join(rootDir, parentResearchId);
+    const parentDir = import_node_path2.default.join(rootDir, parentResearchId);
     const [parentSpec, parentManifest, parentResult] = await Promise.all([
-      import_promises.default.readFile(import_node_path.default.join(parentDir, "spec.json"), "utf8").then((text) => JSON.parse(text)),
-      import_promises.default.readFile(import_node_path.default.join(parentDir, "manifest.json"), "utf8").then((text) => JSON.parse(text)),
-      import_promises.default.readFile(import_node_path.default.join(parentDir, "result.json"), "utf8").then((text) => JSON.parse(text))
+      import_promises.default.readFile(import_node_path2.default.join(parentDir, "spec.json"), "utf8").then((text) => JSON.parse(text)),
+      import_promises.default.readFile(import_node_path2.default.join(parentDir, "manifest.json"), "utf8").then((text) => JSON.parse(text)),
+      import_promises.default.readFile(import_node_path2.default.join(parentDir, "result.json"), "utf8").then((text) => JSON.parse(text))
     ]);
     validateCoreResearchSpec(parentSpec);
     if (parentManifest.status !== "completed") {
@@ -500,15 +667,46 @@ var prepareCoreResearch = async (spec) => {
       return { paths, specSha256, manifest: existingManifest };
     }
   }
+  const supportSources = spec.support ? await Promise.all(
+    [
+      ...new Set(
+        spec.variants.flatMap((variant) => variant.traceFiles ?? [])
+      )
+    ].map(async (file) => ({
+      file: import_node_path2.default.resolve(file),
+      sha256: await sha256File(file).catch((error) => {
+        if (error.code === "ENOENT") return null;
+        throw error;
+      })
+    }))
+  ) : [];
+  const missingSources = supportSources.filter(
+    (source) => source.sha256 === null
+  );
+  const support = spec.support ? missingSources.length ? {
+    schema: "tradejs-core-research-support/v1",
+    status: "missing-evidence",
+    criteria: spec.support
+  } : await assessCoreResearchSupport(spec, spec.support) : void 0;
+  const supportPath = import_node_path2.default.join(paths.researchDir, "support.json");
+  if (support) {
+    for (const source of supportSources) {
+      if (source.sha256 !== null && source.sha256 !== await sha256File(source.file))
+        throw new Error("Support trace changed during preparation");
+    }
+    await writeJsonAtomic(supportPath, { ...support, sources: supportSources });
+  }
   await writeJsonAtomic(paths.specPath, spec);
   const manifest = {
     schema: "tradejs-core-research-manifest/v1",
     researchId: spec.researchId,
     specSha256,
     status: "prepared",
+    ...support ? { support: support.status } : {},
     createdAt: spec.createdAt,
     artifactHashes: {
-      "spec.json": await sha256File(paths.specPath)
+      "spec.json": await sha256File(paths.specPath),
+      ...support ? { "support.json": await sha256File(supportPath) } : {}
     }
   };
   await writeJsonAtomic(paths.manifestPath, manifest);
@@ -527,6 +725,24 @@ var prepareCoreResearch = async (spec) => {
   }
   return { paths, specSha256, manifest };
 };
+var verifyPreparedSupport = async (prepared) => {
+  if (!prepared.manifest.support) return;
+  if (prepared.manifest.support !== "supported") {
+    throw new Error(
+      `Research preflight: ${prepared.manifest.support}; see support.json`
+    );
+  }
+  const file = import_node_path2.default.join(prepared.paths.researchDir, "support.json");
+  const content = await import_promises.default.readFile(file);
+  if ((0, import_node_crypto.createHash)("sha256").update(content).digest("hex") !== prepared.manifest.artifactHashes["support.json"]) {
+    throw new Error("Support report checksum mismatch");
+  }
+  const { sources } = JSON.parse(content.toString());
+  for (const source of sources) {
+    if (source.sha256 !== await sha256File(source.file))
+      throw new Error("Support trace changed after preparation");
+  }
+};
 var verifyCoreResearchArtifacts = async (spec) => {
   const paths = resolveCoreResearchPaths(spec);
   const manifest = JSON.parse(
@@ -539,7 +755,7 @@ var verifyCoreResearchArtifacts = async (spec) => {
     manifest.artifactHashes
   )) {
     const actualHash = await sha256File(
-      import_node_path.default.join(paths.researchDir, relativePath)
+      import_node_path2.default.join(paths.researchDir, relativePath)
     );
     if (actualHash !== expectedHash) {
       throw new Error(`Artifact hash mismatch: ${relativePath}`);
@@ -555,7 +771,7 @@ var verifyCoreResearchArtifacts = async (spec) => {
   };
 };
 var scanCoreResearchStages = async (rootDir) => {
-  const resolvedRoot = import_node_path.default.resolve(rootDir);
+  const resolvedRoot = import_node_path2.default.resolve(rootDir);
   let entries = [];
   try {
     entries = await import_promises.default.readdir(resolvedRoot);
@@ -573,15 +789,15 @@ var scanCoreResearchStages = async (rootDir) => {
   for (const entry of entries.sort(
     (left, right) => left < right ? -1 : left > right ? 1 : 0
   )) {
-    const researchDir = import_node_path.default.join(resolvedRoot, entry);
+    const researchDir = import_node_path2.default.join(resolvedRoot, entry);
     const stats = await import_promises.default.stat(researchDir);
     if (!stats.isDirectory()) continue;
     let spec;
     let manifest;
     try {
       [spec, manifest] = await Promise.all([
-        import_promises.default.readFile(import_node_path.default.join(researchDir, "spec.json"), "utf8").then((text) => JSON.parse(text)),
-        import_promises.default.readFile(import_node_path.default.join(researchDir, "manifest.json"), "utf8").then((text) => JSON.parse(text))
+        import_promises.default.readFile(import_node_path2.default.join(researchDir, "spec.json"), "utf8").then((text) => JSON.parse(text)),
+        import_promises.default.readFile(import_node_path2.default.join(researchDir, "manifest.json"), "utf8").then((text) => JSON.parse(text))
       ]);
     } catch (error) {
       if (error.code === "ENOENT") continue;
@@ -591,7 +807,7 @@ var scanCoreResearchStages = async (rootDir) => {
     if (manifest.specSha256 !== sha256Json(spec)) {
       throw new Error(`Stage index found a spec hash mismatch for ${entry}`);
     }
-    const result = manifest.status === "completed" ? await import_promises.default.readFile(import_node_path.default.join(researchDir, "result.json"), "utf8").then((text) => JSON.parse(text)) : null;
+    const result = manifest.status === "completed" ? await import_promises.default.readFile(import_node_path2.default.join(researchDir, "result.json"), "utf8").then((text) => JSON.parse(text)) : null;
     familyByResearch.set(spec.researchId, spec.hypothesis.family);
     experiments.push({
       researchId: spec.researchId,
@@ -622,7 +838,7 @@ var scanCoreResearchStages = async (rootDir) => {
   return { experiments, familyByResearch };
 };
 var writeCoreResearchStageIndex = async (rootDir) => {
-  const resolvedRoot = import_node_path.default.resolve(rootDir);
+  const resolvedRoot = import_node_path2.default.resolve(rootDir);
   const { experiments, familyByResearch } = await scanCoreResearchStages(resolvedRoot);
   const grouped = /* @__PURE__ */ new Map();
   for (const experiment of experiments) {
@@ -639,7 +855,7 @@ var writeCoreResearchStageIndex = async (rootDir) => {
     generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
     families: [...grouped.entries()].sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0).map(([family, experiments2]) => ({ family, experiments: experiments2 }))
   };
-  await writeJsonAtomic(import_node_path.default.join(resolvedRoot, "index.json"), index);
+  await writeJsonAtomic(import_node_path2.default.join(resolvedRoot, "index.json"), index);
   return index;
 };
 
@@ -651,10 +867,10 @@ var import_node_crypto5 = require("crypto");
 var import_coreResearch = require("@tradejs/infra/coreResearch");
 
 // src/lib/coreResearch/artifacts.ts
-var import_node_fs2 = require("fs");
+var import_node_fs3 = require("fs");
 var import_node_events = require("events");
 var import_promises2 = __toESM(require("fs/promises"));
-var import_node_path2 = __toESM(require("path"));
+var import_node_path3 = __toESM(require("path"));
 var csv = (value) => {
   const text = String(value ?? "");
   return /[",\n]/.test(text) ? `"${text.replaceAll('"', '""')}"` : text;
@@ -667,8 +883,8 @@ var closeOutput = async (output) => {
   await (0, import_node_events.once)(output, "close");
 };
 var writeCoreResearchMatches = async (params) => {
-  await import_promises2.default.mkdir(import_node_path2.default.dirname(params.filePath), { recursive: true });
-  const output = (0, import_node_fs2.createWriteStream)(params.filePath, { encoding: "utf8" });
+  await import_promises2.default.mkdir(import_node_path3.default.dirname(params.filePath), { recursive: true });
+  const output = (0, import_node_fs3.createWriteStream)(params.filePath, { encoding: "utf8" });
   await writeLine(
     output,
     [
@@ -718,8 +934,8 @@ var writeCoreResearchMatches = async (params) => {
   await closeOutput(output);
 };
 var writeCoreResearchTrades = async (params) => {
-  await import_promises2.default.mkdir(import_node_path2.default.dirname(params.filePath), { recursive: true });
-  const output = (0, import_node_fs2.createWriteStream)(params.filePath, { encoding: "utf8" });
+  await import_promises2.default.mkdir(import_node_path3.default.dirname(params.filePath), { recursive: true });
+  const output = (0, import_node_fs3.createWriteStream)(params.filePath, { encoding: "utf8" });
   for (const variant of params.variants) {
     for (const trade of variant.trades) {
       await writeLine(
@@ -1452,9 +1668,9 @@ var compareCoreResearchVariants = (params) => {
 
 // src/lib/coreResearch/dataset.ts
 var import_node_crypto3 = require("crypto");
-var import_node_fs3 = require("fs");
-var import_node_path3 = __toESM(require("path"));
-var import_node_readline = __toESM(require("readline"));
+var import_node_fs4 = require("fs");
+var import_node_path4 = __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);
@@ -1664,11 +1880,11 @@ var readCoreResearchVariant = async (variant) => {
   const seen = /* @__PURE__ */ new Map();
   let duplicateRowsDropped = 0;
   for (const inputPath of variant.files) {
-    const filePath = import_node_path3.default.resolve(inputPath);
-    const input = (0, import_node_fs3.createReadStream)(filePath);
+    const filePath = import_node_path4.default.resolve(inputPath);
+    const input = (0, import_node_fs4.createReadStream)(filePath);
     const hash = (0, import_node_crypto3.createHash)("sha256");
     input.on("data", (chunk) => hash.update(chunk));
-    const lines = import_node_readline.default.createInterface({ input, crlfDelay: Infinity });
+    const lines = import_node_readline2.default.createInterface({ input, crlfDelay: Infinity });
     const fileTrades = [];
     let lineNumber = 0;
     let rows = 0;
@@ -2156,79 +2372,6 @@ var applyCoreResearchRobustnessGuardrails = (params) => {
   }
 };
 
-// src/lib/coreResearch/trace.ts
-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 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
-            });
-        }
-      }
-    } 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/researchRoots.ts
 var import_node_path5 = __toESM(require("path"));
 var SOURCE_REPOSITORY_ROOT_ENV = "TRADEJS_SOURCE_REPOSITORY_ROOT";
@@ -2280,6 +2423,7 @@ var summarizeSupplementalFiles = async (params) => {
 var analyzeCoreResearchPrepared = async (spec, options = {}) => {
   const prepared = options.prepared ?? await prepareCoreResearch(spec);
   const { paths, specSha256 } = prepared;
+  await verifyPreparedSupport(prepared);
   if (prepared.manifest.status === "completed") {
     throw new Error(
       `Research ${spec.researchId} is already completed and immutable; use verify or create a new researchId`
@@ -2550,6 +2694,7 @@ var analyzeCoreResearchPrepared = async (spec, options = {}) => {
     "utf8"
   );
   const artifactHashes = {
+    ...prepared.manifest.artifactHashes,
     "spec.json": await sha256File(paths.specPath),
     "result.json": await sha256File(paths.resultPath),
     "comparison.json": await sha256File(paths.comparisonPath),
@@ -2840,6 +2985,7 @@ var runCoreResearch = async (params) => {
   const { spec } = params;
   const cwd = import_node_path6.default.resolve(params.cwd ?? process.cwd());
   const prepared = await prepareCoreResearch(spec);
+  await verifyPreparedSupport(prepared);
   const resolvedVariants = [];
   for (const variant of spec.variants) {
     if (!variant.command?.length) {
@@ -3085,6 +3231,8 @@ var main = async () => {
         `Prepared ${loaded.spec.researchId}: ${result.paths.researchDir}`
       )
     );
+    if (result.manifest.support)
+      console.log(`Support: ${result.manifest.support} (support.json)`);
     return;
   }
   if (command === "analyze") {