@tradejs/cli 2.0.19 → 2.0.20

package/dist/scripts/coreResearch.js

@@ -0,0 +1,2830 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/scripts/coreResearch.ts
+var coreResearch_exports = {};
+__export(coreResearch_exports, {
+  main: () => main
+});
+module.exports = __toCommonJS(coreResearch_exports);
+var import_promises5 = __toESM(require("fs/promises"));
+var import_node_path6 = __toESM(require("path"));
+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_promises = __toESM(require("fs/promises"));
+var import_node_path = __toESM(require("path"));
+
+// src/lib/coreResearch/types.ts
+var CORE_RESEARCH_SCHEMA = "tradejs-core-research/v1";
+var CORE_RESEARCH_RESULT_SCHEMA = "tradejs-core-research-result/v1";
+var CORE_RESEARCH_LEDGER_SCHEMA = "tradejs-core-research-ledger/v1";
+
+// src/lib/coreResearch/io.ts
+var RESEARCH_ID_RE = /^[a-z0-9][a-z0-9._-]{2,120}$/;
+var SHA256_RE = /^[a-f0-9]{64}$/;
+var canonicalJson = (value) => {
+  const normalize = (current) => {
+    if (Array.isArray(current)) return current.map(normalize);
+    if (current && typeof current === "object") {
+      return Object.fromEntries(
+        Object.entries(current).filter(([, entry]) => entry !== void 0).sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0).map(([key, entry]) => [key, normalize(entry)])
+      );
+    }
+    return current;
+  };
+  return JSON.stringify(normalize(value));
+};
+var sha256Text = (value) => (0, import_node_crypto.createHash)("sha256").update(value).digest("hex");
+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);
+  for await (const chunk of input) hash.update(chunk);
+  return hash.digest("hex");
+};
+function assert(condition, message) {
+  if (!condition) throw new Error(`Invalid core research spec: ${message}`);
+}
+var assertFinite = (value, name) => {
+  assert(typeof value === "number" && Number.isFinite(value), name);
+};
+var validateCoreResearchSpec = (value) => {
+  assert(value && typeof value === "object", "root must be an object");
+  const spec = value;
+  assert(
+    spec.schema === CORE_RESEARCH_SCHEMA,
+    `schema must be ${CORE_RESEARCH_SCHEMA}`
+  );
+  assert(
+    RESEARCH_ID_RE.test(spec.researchId),
+    "researchId must be filesystem-safe"
+  );
+  assert(
+    ["screen", "isolated_long", "confirmation"].includes(spec.stage),
+    "stage must be screen, isolated_long, or confirmation"
+  );
+  assert(
+    spec.stage === "screen" || (spec.parentResearchIds?.length ?? 0) > 0,
+    "isolated_long and confirmation stages require parentResearchIds"
+  );
+  if (spec.parentResearchIds) {
+    assert(
+      spec.parentResearchIds.every((id) => RESEARCH_ID_RE.test(id)),
+      "parentResearchIds must contain filesystem-safe research IDs"
+    );
+  }
+  assert(Boolean(spec.strategy?.trim()), "strategy is required");
+  assert(
+    !Number.isNaN(Date.parse(spec.createdAt)),
+    "createdAt must be ISO-8601"
+  );
+  assert(
+    Boolean(spec.hypothesis?.family?.trim()),
+    "hypothesis.family is required"
+  );
+  assert(
+    Boolean(spec.hypothesis?.claim?.trim()),
+    "hypothesis.claim is required"
+  );
+  assert(
+    Boolean(spec.hypothesis?.mechanism?.trim()),
+    "hypothesis.mechanism is required"
+  );
+  assert(
+    ["ALL", "LONG", "SHORT"].includes(spec.hypothesis?.target),
+    "hypothesis.target must be ALL, LONG, or SHORT"
+  );
+  assert(
+    Array.isArray(spec.universe?.symbols) && spec.universe.symbols.length > 0,
+    "universe.symbols is required"
+  );
+  assert(
+    new Set(spec.universe.symbols).size === spec.universe.symbols.length,
+    "universe.symbols must be unique"
+  );
+  assert(
+    sha256Json(spec.universe.symbols) === spec.universe.sha256,
+    "universe.sha256 does not match the ordered symbol array"
+  );
+  assert(
+    SHA256_RE.test(spec.universe.sha256),
+    "universe.sha256 must be a lowercase SHA-256"
+  );
+  assertFinite(spec.window?.start, "window.start must be finite");
+  assertFinite(spec.window?.end, "window.end must be finite");
+  assert(spec.window.end > spec.window.start, "window.end must be after start");
+  assert(
+    Array.isArray(spec.window.terminalDays) && spec.window.terminalDays.every(
+      (days) => Number.isInteger(days) && days > 0
+    ),
+    "window.terminalDays must contain positive integers"
+  );
+  assert(
+    Number.isInteger(spec.window.folds) && spec.window.folds >= 2,
+    "window.folds must be >= 2"
+  );
+  assert(
+    Array.isArray(spec.variants) && spec.variants.length >= 2,
+    "at least two variants are required"
+  );
+  assert(
+    spec.variants.filter((variant) => variant.role === "control").length === 1,
+    "exactly one control is required"
+  );
+  assert(
+    spec.variants.some((variant) => variant.role === "candidate"),
+    "at least one candidate is required"
+  );
+  assert(
+    new Set(spec.variants.map((variant) => variant.id)).size === spec.variants.length,
+    "variant ids must be unique"
+  );
+  for (const variant of spec.variants) {
+    assert(
+      RESEARCH_ID_RE.test(variant.id),
+      `variant id ${variant.id} is invalid`
+    );
+    assert(
+      Boolean(variant.configName?.trim()),
+      `variant ${variant.id} configName is required`
+    );
+    assert(
+      variant.resolvedConfig && typeof variant.resolvedConfig === "object" && !Array.isArray(variant.resolvedConfig) && Object.keys(variant.resolvedConfig).length > 0,
+      `variant ${variant.id} resolvedConfig must be a non-empty object`
+    );
+    assert(
+      sha256Json(variant.resolvedConfig) === variant.configSha256,
+      `variant ${variant.id} configSha256 does not match resolvedConfig`
+    );
+    assert(
+      SHA256_RE.test(variant.configSha256),
+      `variant ${variant.id} configSha256 must be a lowercase SHA-256`
+    );
+    assert(
+      Array.isArray(variant.files),
+      `variant ${variant.id} files must be an array`
+    );
+    assert(
+      variant.files.length > 0 || Array.isArray(variant.command) && variant.command.length > 0,
+      `variant ${variant.id} needs files or a command`
+    );
+    if (variant.runId != null) {
+      assert(
+        Boolean(variant.runId.trim()),
+        `variant ${variant.id} runId is empty`
+      );
+    }
+  }
+  assert(
+    Number.isInteger(spec.selection?.minimumTrades) && spec.selection.minimumTrades >= 0,
+    "selection.minimumTrades must be non-negative"
+  );
+  assertFinite(
+    spec.selection?.minimumCadencePerDay,
+    "selection.minimumCadencePerDay must be finite"
+  );
+  assert(
+    spec.selection.minimumCadencePerDay >= 0,
+    "selection.minimumCadencePerDay must be non-negative"
+  );
+  const allowedMetrics = /* @__PURE__ */ new Set([
+    "pnl",
+    "pnlPerTrade",
+    "profitFactor",
+    "winRatePct",
+    "realizedMaxDrawdown",
+    "cadencePerDay"
+  ]);
+  const allowedComparisons = /* @__PURE__ */ new Set(["gt", "gte", "lt", "lte"]);
+  for (const [name, rules] of Object.entries({
+    targetRules: spec.selection.targetRules,
+    aggregateRules: spec.selection.aggregateRules,
+    nonTargetRules: spec.selection.nonTargetRules,
+    terminalRules: spec.selection.terminalRules ?? [],
+    costStressRules: spec.selection.costStressRules ?? []
+  })) {
+    assert(Array.isArray(rules), `selection.${name} must be an array`);
+    for (const rule of rules) {
+      assert(
+        allowedMetrics.has(rule.metric),
+        `selection.${name} contains an unsupported metric`
+      );
+      assert(
+        allowedComparisons.has(rule.comparison),
+        `selection.${name} contains an unsupported comparison`
+      );
+      if (rule.value != null) {
+        assertFinite(rule.value, `selection.${name} value must be finite`);
+      }
+    }
+  }
+  assertFinite(
+    spec.execution?.maxLossValue,
+    "execution.maxLossValue must be finite"
+  );
+  assert(
+    spec.execution.maxLossValue > 0,
+    "execution.maxLossValue must be positive"
+  );
+  assert(
+    Number.isInteger(spec.robustness?.bootstrapIterations) && spec.robustness.bootstrapIterations >= 100,
+    "robustness.bootstrapIterations must be >= 100"
+  );
+  assert(
+    spec.robustness.confidenceLevel > 0 && spec.robustness.confidenceLevel < 1,
+    "robustness.confidenceLevel must be in (0, 1)"
+  );
+  assert(
+    Number.isInteger(spec.robustness.clusterDays) && spec.robustness.clusterDays > 0,
+    "robustness.clusterDays must be positive"
+  );
+  assert(
+    Number.isInteger(spec.robustness.minimumFoldTrades) && spec.robustness.minimumFoldTrades >= 0,
+    "robustness.minimumFoldTrades must be a non-negative integer"
+  );
+  if (spec.selection.maximumPortfolioDrawdownRegressionPct != null) {
+    assert(
+      Number.isFinite(spec.selection.maximumPortfolioDrawdownRegressionPct) && spec.selection.maximumPortfolioDrawdownRegressionPct >= 0,
+      "selection.maximumPortfolioDrawdownRegressionPct must be non-negative"
+    );
+  }
+  if (spec.selection.maximumHolmPValue != null) {
+    assert(
+      spec.selection.maximumHolmPValue >= 0 && spec.selection.maximumHolmPValue <= 1,
+      "selection.maximumHolmPValue must be in [0, 1]"
+    );
+  }
+  if (spec.selection.minimumPositiveFoldPct != null) {
+    assert(
+      spec.selection.minimumPositiveFoldPct >= 0 && spec.selection.minimumPositiveFoldPct <= 100,
+      "selection.minimumPositiveFoldPct must be in [0, 100]"
+    );
+  }
+  assert(
+    Array.isArray(spec.robustness.costStressBps) && spec.robustness.costStressBps.every(
+      (entry) => Number.isFinite(entry) && entry >= 0
+    ),
+    "robustness.costStressBps must contain non-negative finite values"
+  );
+  assert(
+    Boolean(spec.artifacts?.rootDir?.trim()),
+    "artifacts.rootDir is required"
+  );
+  assert(
+    Boolean(spec.artifacts?.ledgerPath?.trim()),
+    "artifacts.ledgerPath is required"
+  );
+  return spec;
+};
+var loadCoreResearchSpec = async (specPath) => {
+  const resolvedPath = import_node_path.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);
+  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")
+  };
+};
+var writeJsonAtomic = async (filePath, value) => {
+  await import_promises.default.mkdir(import_node_path.default.dirname(filePath), { recursive: true });
+  const temporaryPath = `${filePath}.${process.pid}.${Date.now()}.tmp`;
+  await import_promises.default.writeFile(temporaryPath, `${canonicalJson(value)}
+`, "utf8");
+  await import_promises.default.rename(temporaryPath, filePath);
+};
+var buildLedgerRecordHash = (record) => sha256Json(record);
+var readCoreResearchLedger = async (ledgerPath) => {
+  let text = "";
+  try {
+    text = await import_promises.default.readFile(ledgerPath, "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT") return [];
+    throw error;
+  }
+  return text.split("\n").filter(Boolean).map((line, index) => {
+    try {
+      return JSON.parse(line);
+    } catch (error) {
+      throw new Error(
+        `Invalid ledger JSON at line ${index + 1}: ${String(error)}`
+      );
+    }
+  });
+};
+var verifyCoreResearchLedger = (records) => {
+  let previousHash = null;
+  records.forEach((record, index) => {
+    if (record.schema !== CORE_RESEARCH_LEDGER_SCHEMA) {
+      throw new Error(`Ledger line ${index + 1} has unsupported schema`);
+    }
+    if (record.sequence !== index + 1) {
+      throw new Error(`Ledger line ${index + 1} has invalid sequence`);
+    }
+    if (record.previousHash !== previousHash) {
+      throw new Error(`Ledger line ${index + 1} breaks the hash chain`);
+    }
+    const { recordHash, ...payload } = record;
+    if (buildLedgerRecordHash(payload) !== recordHash) {
+      throw new Error(`Ledger line ${index + 1} has an invalid record hash`);
+    }
+    previousHash = recordHash;
+  });
+  return { records: records.length, head: previousHash };
+};
+var appendCoreResearchLedger = async (params) => {
+  const { ledgerPath } = params;
+  await import_promises.default.mkdir(import_node_path.default.dirname(ledgerPath), { recursive: true });
+  const lockPath = `${ledgerPath}.lock`;
+  let lock = null;
+  try {
+    lock = await import_promises.default.open(lockPath, "wx");
+    const records = await readCoreResearchLedger(ledgerPath);
+    const verified = verifyCoreResearchLedger(records);
+    const payload = {
+      schema: CORE_RESEARCH_LEDGER_SCHEMA,
+      sequence: records.length + 1,
+      recordedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      researchId: params.researchId,
+      event: params.event,
+      specSha256: params.specSha256,
+      hypothesisFamily: params.hypothesisFamily,
+      hypothesesInRecord: params.hypothesesInRecord ?? 0,
+      artifactHashes: params.artifactHashes ?? {},
+      previousHash: verified.head
+    };
+    const record = {
+      ...payload,
+      recordHash: buildLedgerRecordHash(payload)
+    };
+    await import_promises.default.appendFile(ledgerPath, `${canonicalJson(record)}
+`, "utf8");
+    return record;
+  } catch (error) {
+    if (error.code === "EEXIST") {
+      throw new Error(`Core research ledger is locked: ${ledgerPath}`);
+    }
+    throw error;
+  } finally {
+    await lock?.close();
+    await import_promises.default.rm(lockPath, { force: true });
+  }
+};
+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 passedParentCandidateConfigShas = /* @__PURE__ */ new Set();
+  for (const parentResearchId of spec.parentResearchIds ?? []) {
+    const parentDir = import_node_path.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))
+    ]);
+    validateCoreResearchSpec(parentSpec);
+    if (parentManifest.status !== "completed") {
+      throw new Error(`Parent research ${parentResearchId} is not completed`);
+    }
+    if (parentSpec.stage !== expectedParentStage) {
+      throw new Error(
+        `${spec.stage} requires a ${expectedParentStage} parent, found ${parentSpec.stage}`
+      );
+    }
+    if (parentSpec.hypothesis.family !== spec.hypothesis.family) {
+      throw new Error(
+        `Parent research ${parentResearchId} belongs to a different hypothesis family`
+      );
+    }
+    if (!parentResult.comparisons.some(
+      (comparison) => comparison.selection.passed
+    )) {
+      throw new Error(
+        `Parent research ${parentResearchId} has no candidate that passed selection`
+      );
+    }
+    for (const comparison of parentResult.comparisons.filter(
+      (entry) => entry.selection.passed
+    )) {
+      const candidate = parentResult.variants.find(
+        (entry) => entry.variant.id === comparison.candidateId
+      );
+      if (candidate) {
+        passedParentCandidateConfigShas.add(candidate.variant.configSha256);
+      }
+    }
+  }
+  if (!spec.variants.some(
+    (variant) => variant.role === "candidate" && passedParentCandidateConfigShas.has(variant.configSha256)
+  )) {
+    throw new Error(
+      `${spec.stage} does not carry forward a passed parent candidate config SHA`
+    );
+  }
+};
+var prepareCoreResearch = async (spec) => {
+  validateCoreResearchSpec(spec);
+  await validateCoreResearchParentLineage(spec);
+  const specSha256 = sha256Json(spec);
+  const paths = resolveCoreResearchPaths(spec);
+  await import_promises.default.mkdir(paths.researchDir, { recursive: true });
+  let existing = null;
+  let existingManifest = null;
+  try {
+    existing = JSON.parse(
+      await import_promises.default.readFile(paths.specPath, "utf8")
+    );
+  } catch (error) {
+    if (error.code !== "ENOENT") throw error;
+  }
+  if (existing && sha256Json(existing) !== specSha256) {
+    throw new Error(
+      `Research ${spec.researchId} is immutable and already has a different spec`
+    );
+  }
+  if (existing) {
+    try {
+      existingManifest = JSON.parse(
+        await import_promises.default.readFile(paths.manifestPath, "utf8")
+      );
+    } catch (error) {
+      if (error.code !== "ENOENT") throw error;
+    }
+    if (existingManifest) {
+      return { paths, specSha256, manifest: existingManifest };
+    }
+  }
+  await writeJsonAtomic(paths.specPath, spec);
+  const manifest = {
+    schema: "tradejs-core-research-manifest/v1",
+    researchId: spec.researchId,
+    specSha256,
+    status: "prepared",
+    createdAt: spec.createdAt,
+    artifactHashes: {
+      "spec.json": await sha256File(paths.specPath)
+    }
+  };
+  await writeJsonAtomic(paths.manifestPath, manifest);
+  if (!existing) {
+    await appendCoreResearchLedger({
+      ledgerPath: paths.ledgerPath,
+      researchId: spec.researchId,
+      event: "prepared",
+      specSha256,
+      hypothesisFamily: spec.hypothesis.family,
+      hypothesesInRecord: spec.variants.filter(
+        (variant) => variant.role === "candidate"
+      ).length,
+      artifactHashes: manifest.artifactHashes
+    });
+  }
+  return { paths, specSha256, manifest };
+};
+var verifyCoreResearchArtifacts = async (spec) => {
+  const paths = resolveCoreResearchPaths(spec);
+  const manifest = JSON.parse(
+    await import_promises.default.readFile(paths.manifestPath, "utf8")
+  );
+  if (manifest.specSha256 !== sha256Json(spec)) {
+    throw new Error("Manifest spec hash does not match the supplied spec");
+  }
+  for (const [relativePath, expectedHash] of Object.entries(
+    manifest.artifactHashes
+  )) {
+    const actualHash = await sha256File(
+      import_node_path.default.join(paths.researchDir, relativePath)
+    );
+    if (actualHash !== expectedHash) {
+      throw new Error(`Artifact hash mismatch: ${relativePath}`);
+    }
+  }
+  const ledger = verifyCoreResearchLedger(
+    await readCoreResearchLedger(paths.ledgerPath)
+  );
+  return {
+    researchId: spec.researchId,
+    artifacts: Object.keys(manifest.artifactHashes).length,
+    ledger
+  };
+};
+var scanCoreResearchStages = async (rootDir) => {
+  const resolvedRoot = import_node_path.default.resolve(rootDir);
+  let entries = [];
+  try {
+    entries = await import_promises.default.readdir(resolvedRoot);
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return {
+        experiments: [],
+        familyByResearch: /* @__PURE__ */ new Map()
+      };
+    }
+    throw error;
+  }
+  const experiments = [];
+  const familyByResearch = /* @__PURE__ */ new Map();
+  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 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))
+      ]);
+    } catch (error) {
+      if (error.code === "ENOENT") continue;
+      throw error;
+    }
+    validateCoreResearchSpec(spec);
+    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;
+    familyByResearch.set(spec.researchId, spec.hypothesis.family);
+    experiments.push({
+      researchId: spec.researchId,
+      stage: spec.stage,
+      parentResearchIds: spec.parentResearchIds ?? [],
+      specSha256: manifest.specSha256,
+      manifestStatus: manifest.status,
+      passedCandidates: result?.comparisons.filter((comparison) => comparison.selection.passed).map((comparison) => comparison.candidateId) ?? [],
+      evidence: result?.evidence ?? null
+    });
+  }
+  for (const experiment of experiments) {
+    for (const parentId of experiment.parentResearchIds) {
+      const parentFamily = familyByResearch.get(parentId);
+      const family = familyByResearch.get(experiment.researchId);
+      if (!parentFamily) {
+        throw new Error(
+          `Stage ${experiment.researchId} references missing parent ${parentId}`
+        );
+      }
+      if (parentFamily !== family) {
+        throw new Error(
+          `Stage ${experiment.researchId} crosses hypothesis families`
+        );
+      }
+    }
+  }
+  return { experiments, familyByResearch };
+};
+var writeCoreResearchStageIndex = async (rootDir) => {
+  const resolvedRoot = import_node_path.default.resolve(rootDir);
+  const { experiments, familyByResearch } = await scanCoreResearchStages(resolvedRoot);
+  const grouped = /* @__PURE__ */ new Map();
+  for (const experiment of experiments) {
+    const family = familyByResearch.get(experiment.researchId);
+    if (!family) {
+      throw new Error(`Stage index lost family for ${experiment.researchId}`);
+    }
+    const bucket = grouped.get(family) ?? [];
+    bucket.push(experiment);
+    grouped.set(family, bucket);
+  }
+  const index = {
+    schema: "tradejs-core-research-stage-index/v1",
+    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);
+  return index;
+};
+
+// src/lib/coreResearch/orchestrator.ts
+var import_promises4 = __toESM(require("fs/promises"));
+var import_node_path5 = __toESM(require("path"));
+var import_node_child_process = require("child_process");
+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_events = require("events");
+var import_promises2 = __toESM(require("fs/promises"));
+var import_node_path2 = __toESM(require("path"));
+var csv = (value) => {
+  const text = String(value ?? "");
+  return /[",\n]/.test(text) ? `"${text.replaceAll('"', '""')}"` : text;
+};
+var writeLine = async (output, line) => {
+  if (!output.write(line)) await (0, import_node_events.once)(output, "drain");
+};
+var closeOutput = async (output) => {
+  output.end();
+  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 writeLine(
+    output,
+    [
+      "controlId",
+      "candidateId",
+      "identity",
+      "symbol",
+      "direction",
+      "controlSignalTimestamp",
+      "candidateSignalTimestamp",
+      "controlPnl",
+      "candidatePnl",
+      "pnlDelta",
+      "exitReasonChanged"
+    ].map(csv).join(",") + "\n"
+  );
+  for (const comparison of params.comparisons) {
+    for (const pair of comparison.matchedPairs) {
+      await writeLine(
+        output,
+        [
+          comparison.controlId,
+          comparison.candidateId,
+          pair.identity,
+          pair.control.symbol,
+          pair.control.direction,
+          pair.control.signalTimestamp,
+          pair.candidate.signalTimestamp,
+          pair.control.netProfit,
+          pair.candidate.netProfit,
+          pair.pnlDelta,
+          pair.exitReasonChanged
+        ].map(csv).join(",") + "\n"
+      );
+    }
+  }
+  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" });
+  for (const variant of params.variants) {
+    for (const trade of variant.trades) {
+      await writeLine(
+        output,
+        `${canonicalJson({ variantId: variant.variantId, ...trade })}
+`
+      );
+    }
+  }
+  await closeOutput(output);
+};
+
+// src/lib/coreResearch/metrics.ts
+var DAY_MS = 24 * 60 * 60 * 1e3;
+var CORE_RESEARCH_COHORTS = [
+  "ALL",
+  "LONG",
+  "SHORT"
+];
+var selectCohort = (trades, cohort) => cohort === "ALL" ? trades : trades.filter((trade) => trade.direction === cohort);
+var quantile = (sorted, probability) => {
+  if (!sorted.length) return null;
+  const position = (sorted.length - 1) * probability;
+  const lower = Math.floor(position);
+  const upper = Math.ceil(position);
+  if (lower === upper) return sorted[lower];
+  const weight = position - lower;
+  return sorted[lower] * (1 - weight) + sorted[upper] * weight;
+};
+var compareChronologicalTrades = (left, right) => left.exitTimestamp - right.exitTimestamp || (left.signalId < right.signalId ? -1 : left.signalId > right.signalId ? 1 : 0);
+var orderCoreResearchTrades = (trades) => {
+  for (let index = 1; index < trades.length; index += 1) {
+    if (compareChronologicalTrades(trades[index - 1], trades[index]) > 0) {
+      return [...trades].sort(compareChronologicalTrades);
+    }
+  }
+  return trades;
+};
+var summarizeCoreResearchTrades = (trades, periodDays) => {
+  const sorted = orderCoreResearchTrades(trades);
+  let pnl = 0;
+  let grossProfit = 0;
+  let grossLoss = 0;
+  let wins = 0;
+  let losses = 0;
+  let breakeven = 0;
+  let equity = 0;
+  let peak = 0;
+  let realizedMaxDrawdown = 0;
+  let consecutiveLosses = 0;
+  let maximumConsecutiveLosses = 0;
+  for (const trade of sorted) {
+    pnl += trade.netProfit;
+    if (trade.netProfit > 0) {
+      wins += 1;
+      grossProfit += trade.netProfit;
+      consecutiveLosses = 0;
+    } else {
+      losses += 1;
+      if (trade.netProfit === 0) breakeven += 1;
+      else {
+        grossLoss += Math.abs(trade.netProfit);
+        consecutiveLosses += 1;
+        maximumConsecutiveLosses = Math.max(
+          maximumConsecutiveLosses,
+          consecutiveLosses
+        );
+      }
+    }
+    equity += trade.netProfit;
+    peak = Math.max(peak, equity);
+    realizedMaxDrawdown = Math.max(realizedMaxDrawdown, peak - equity);
+  }
+  const count = sorted.length;
+  const pnlDistribution = sorted.map((trade) => trade.netProfit).sort((left, right) => left - right);
+  const holdingHours = sorted.map((trade) => (trade.exitTimestamp - trade.entryTimestamp) / 36e5).sort((left, right) => left - right);
+  const averageWin = wins > 0 ? grossProfit / wins : null;
+  const strictLosses = losses - breakeven;
+  const averageLoss = strictLosses > 0 ? grossLoss / strictLosses : null;
+  return {
+    trades: count,
+    wins,
+    losses,
+    breakeven,
+    pnl,
+    pnlPerTrade: count > 0 ? pnl / count : null,
+    grossProfit,
+    grossLoss,
+    profitFactor: grossLoss > 0 ? grossProfit / grossLoss : null,
+    profitFactorStatus: grossLoss > 0 ? "finite" : grossProfit > 0 ? "infinite_no_gross_loss" : "undefined",
+    winRatePct: count > 0 ? wins / count * 100 : null,
+    realizedMaxDrawdown,
+    cadencePerDay: periodDays > 0 ? count / periodDays : null,
+    averageWin,
+    averageLoss,
+    payoffRatio: averageWin != null && averageLoss != null && averageLoss > 0 ? averageWin / averageLoss : null,
+    medianPnl: quantile(pnlDistribution, 0.5),
+    pnlP05: quantile(pnlDistribution, 0.05),
+    pnlP95: quantile(pnlDistribution, 0.95),
+    medianHoldingHours: quantile(holdingHours, 0.5),
+    maximumConsecutiveLosses
+  };
+};
+var summarizeCoreResearchCohorts = (trades, periodDays) => Object.fromEntries(
+  CORE_RESEARCH_COHORTS.map((cohort) => [
+    cohort,
+    summarizeCoreResearchTrades(selectCohort(trades, cohort), periodDays)
+  ])
+);
+var summarizeCoreResearchWindow = (params) => {
+  const { trades, label, start, end } = params;
+  const periodDays = (end - start) / DAY_MS;
+  const selected = trades.filter(
+    (trade) => trade.exitTimestamp >= start && trade.exitTimestamp < end
+  );
+  return {
+    label,
+    start,
+    end,
+    periodDays,
+    cohorts: summarizeCoreResearchCohorts(selected, periodDays)
+  };
+};
+var buildTerminalWindows = (params) => params.terminalDays.map(
+  (days) => summarizeCoreResearchWindow({
+    trades: params.trades,
+    label: `${days}d`,
+    start: params.end - days * DAY_MS,
+    end: params.end
+  })
+);
+var buildEqualTimeFolds = (params) => {
+  const duration = (params.end - params.start) / params.folds;
+  return Array.from({ length: params.folds }, (_, index) => {
+    const start = params.start + index * duration;
+    const end = index === params.folds - 1 ? params.end : params.start + (index + 1) * duration;
+    return summarizeCoreResearchWindow({
+      trades: params.trades,
+      label: `fold-${index + 1}`,
+      start,
+      end
+    });
+  });
+};
+var buildMonthlyWindows = (params) => {
+  const windows = [];
+  const cursor = new Date(params.start);
+  cursor.setUTCDate(1);
+  cursor.setUTCHours(0, 0, 0, 0);
+  while (cursor.getTime() < params.end) {
+    const monthStart = Math.max(cursor.getTime(), params.start);
+    cursor.setUTCMonth(cursor.getUTCMonth() + 1);
+    const monthEnd = Math.min(cursor.getTime(), params.end);
+    windows.push(
+      summarizeCoreResearchWindow({
+        trades: params.trades,
+        label: new Date(monthStart).toISOString().slice(0, 7),
+        start: monthStart,
+        end: monthEnd
+      })
+    );
+  }
+  return windows;
+};
+var buildRegimeMetrics = (trades, periodDays) => {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const trade of trades) {
+    const bucket = grouped.get(trade.regime.key) ?? [];
+    bucket.push(trade);
+    grouped.set(trade.regime.key, bucket);
+  }
+  return Object.fromEntries(
+    [...grouped.entries()].sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0).map(([key, bucket]) => [
+      key,
+      summarizeCoreResearchCohorts(bucket, periodDays)
+    ])
+  );
+};
+var buildCostStress = (params) => params.extraRoundTripBps.map((extraRoundTripBps) => {
+  const stressed = params.trades.map((trade) => ({
+    ...trade,
+    netProfit: trade.netProfit - Math.abs(trade.entryPrice * trade.qty) * extraRoundTripBps / 1e4
+  }));
+  return {
+    extraRoundTripBps,
+    cohorts: summarizeCoreResearchCohorts(stressed, params.periodDays)
+  };
+});
+
+// src/lib/coreResearch/rules.ts
+var getCoreResearchMetricValue = (metrics, metric) => {
+  if (metric === "profitFactor" && metrics.profitFactorStatus === "infinite_no_gross_loss") {
+    return Number.POSITIVE_INFINITY;
+  }
+  const value = metrics[metric];
+  return typeof value === "number" && !Number.isNaN(value) ? value : null;
+};
+var compareNumbers = (actual, expected, comparison) => {
+  if (actual == null) return false;
+  if (comparison === "gt") return actual > expected;
+  if (comparison === "gte") return actual >= expected;
+  if (comparison === "lt") return actual < expected;
+  return actual <= expected;
+};
+var evaluateCoreResearchThresholdRule = (params) => {
+  const actual = getCoreResearchMetricValue(
+    params.candidate,
+    params.rule.metric
+  );
+  const control = getCoreResearchMetricValue(
+    params.control,
+    params.rule.metric
+  );
+  const offset = params.rule.value ?? 0;
+  const expected = params.rule.relativeToControl === false ? offset : control == null ? Number.NaN : control + offset;
+  return {
+    passed: !Number.isNaN(expected) && compareNumbers(actual, expected, params.rule.comparison),
+    actual,
+    control,
+    expected
+  };
+};
+
+// src/lib/coreResearch/statistics.ts
+var import_node_crypto2 = require("crypto");
+var createSeededRandom = (seedText) => {
+  const digest = (0, import_node_crypto2.createHash)("sha256").update(seedText).digest();
+  let state = digest.readUInt32LE(0) || 1;
+  return () => {
+    state ^= state << 13;
+    state ^= state >>> 17;
+    state ^= state << 5;
+    return (state >>> 0) / 4294967296;
+  };
+};
+var percentile = (sorted, probability) => {
+  if (!sorted.length) return Number.NaN;
+  const index = Math.min(
+    sorted.length - 1,
+    Math.max(0, Math.floor(probability * sorted.length))
+  );
+  return sorted[index];
+};
+var calendarClusterBootstrap = (params) => {
+  const clusterMs = params.clusterDays * DAY_MS;
+  const buckets = /* @__PURE__ */ new Map();
+  if (params.start != null && params.end != null && params.end > params.start) {
+    const first = Math.floor(params.start / clusterMs);
+    const last = Math.ceil(params.end / clusterMs);
+    for (let bucket = first; bucket < last; bucket += 1) {
+      buckets.set(bucket, { control: 0, candidate: 0 });
+    }
+  }
+  const add = (trades, field) => {
+    for (const trade of trades) {
+      const bucket = Math.floor(trade.exitTimestamp / clusterMs);
+      const current = buckets.get(bucket) ?? { control: 0, candidate: 0 };
+      current[field] += trade.netProfit;
+      buckets.set(bucket, current);
+    }
+  };
+  add(params.control, "control");
+  add(params.candidate, "candidate");
+  const deltas = [...buckets.entries()].sort(([left], [right]) => left - right).map(([, value]) => value.candidate - value.control);
+  if (!deltas.length) {
+    return {
+      method: "calendar-cluster-bootstrap",
+      clusterDays: params.clusterDays,
+      iterations: params.iterations,
+      confidenceLevel: params.confidenceLevel,
+      observedMeanPnlDelta: null,
+      confidenceInterval: null,
+      probabilityPositive: null,
+      oneSidedPValue: null,
+      holmAdjustedPValue: null
+    };
+  }
+  const random = createSeededRandom(params.seed);
+  const samples = [];
+  for (let iteration = 0; iteration < params.iterations; iteration += 1) {
+    let sum = 0;
+    for (let index = 0; index < deltas.length; index += 1) {
+      sum += deltas[Math.floor(random() * deltas.length)];
+    }
+    samples.push(sum / deltas.length);
+  }
+  samples.sort((left, right) => left - right);
+  const alpha = 1 - params.confidenceLevel;
+  const positive = samples.filter((value) => value > 0).length;
+  const probabilityPositive = positive / samples.length;
+  return {
+    method: "calendar-cluster-bootstrap",
+    clusterDays: params.clusterDays,
+    iterations: params.iterations,
+    confidenceLevel: params.confidenceLevel,
+    observedMeanPnlDelta: deltas.reduce((sum, value) => sum + value, 0) / deltas.length,
+    confidenceInterval: [
+      percentile(samples, alpha / 2),
+      percentile(samples, 1 - alpha / 2)
+    ],
+    probabilityPositive,
+    oneSidedPValue: 1 - probabilityPositive,
+    holmAdjustedPValue: null
+  };
+};
+var applyHolmCorrection = (results, familyHypotheses = results.length) => {
+  const ranked = results.map((result, index) => ({
+    index,
+    p: result.oneSidedPValue
+  })).filter((entry) => entry.p != null).sort((left, right) => left.p - right.p);
+  let previous = 0;
+  ranked.forEach((entry, rank) => {
+    const adjusted = Math.min(
+      1,
+      Math.max(previous, entry.p * Math.max(1, familyHypotheses - rank))
+    );
+    results[entry.index].holmAdjustedPValue = adjusted;
+    previous = adjusted;
+  });
+};
+var inverseNormalCdf = (probability) => {
+  const p = Math.min(1 - 1e-12, Math.max(1e-12, probability));
+  const a = [
+    -39.69683028665376,
+    220.9460984245205,
+    -275.9285104469687,
+    138.357751867269,
+    -30.66479806614716,
+    2.506628277459239
+  ];
+  const b = [
+    -54.47609879822406,
+    161.5858368580409,
+    -155.6989798598866,
+    66.80131188771972,
+    -13.28068155288572
+  ];
+  const c = [
+    -0.007784894002430293,
+    -0.3223964580411365,
+    -2.400758277161838,
+    -2.549732539343734,
+    4.374664141464968,
+    2.938163982698783
+  ];
+  const d = [
+    0.007784695709041462,
+    0.3224671290700398,
+    2.445134137142996,
+    3.754408661907416
+  ];
+  if (p < 0.02425) {
+    const q2 = Math.sqrt(-2 * Math.log(p));
+    return (((((c[0] * q2 + c[1]) * q2 + c[2]) * q2 + c[3]) * q2 + c[4]) * q2 + c[5]) / ((((d[0] * q2 + d[1]) * q2 + d[2]) * q2 + d[3]) * q2 + 1);
+  }
+  if (p > 1 - 0.02425) return -inverseNormalCdf(1 - p);
+  const q = p - 0.5;
+  const r = q * q;
+  return (((((a[0] * r + a[1]) * r + a[2]) * r + a[3]) * r + a[4]) * r + a[5]) * q / (((((b[0] * r + b[1]) * r + b[2]) * r + b[3]) * r + b[4]) * r + 1);
+};
+var erf = (value) => {
+  const sign = value < 0 ? -1 : 1;
+  const x = Math.abs(value);
+  const t = 1 / (1 + 0.3275911 * x);
+  const y = 1 - ((((1.061405429 * t - 1.453152027) * t + 1.421413741) * t - 0.284496736) * t + 0.254829592) * t * Math.exp(-x * x);
+  return sign * y;
+};
+var normalCdf = (value) => 0.5 * (1 + erf(value / Math.SQRT2));
+var deflatedSharpeDiagnostic = (returns, trials) => {
+  const periods = returns.length;
+  if (periods < 3) {
+    return {
+      periods,
+      observedSharpe: null,
+      expectedMaximumSharpe: null,
+      probabilityAboveSelectionBias: null
+    };
+  }
+  const mean = returns.reduce((sum, value) => sum + value, 0) / periods;
+  const centered = returns.map((value) => value - mean);
+  const variance = centered.reduce((sum, value) => sum + value * value, 0) / (periods - 1);
+  const standardDeviation = Math.sqrt(variance);
+  if (!(standardDeviation > 0)) {
+    return {
+      periods,
+      observedSharpe: null,
+      expectedMaximumSharpe: null,
+      probabilityAboveSelectionBias: null
+    };
+  }
+  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 standardError = Math.sqrt(
+    Math.max(
+      1e-12,
+      (1 - skew * observedSharpe + (kurtosis - 1) / 4 * observedSharpe ** 2) / (periods - 1)
+    )
+  );
+  return {
+    periods,
+    observedSharpe,
+    expectedMaximumSharpe,
+    probabilityAboveSelectionBias: normalCdf(
+      (observedSharpe - expectedMaximumSharpe) / standardError
+    )
+  };
+};
+var combinations = (items, choose) => {
+  const output = [];
+  const visit = (start, selected) => {
+    if (output.length >= 512) return;
+    if (selected.length === choose) {
+      output.push(selected);
+      return;
+    }
+    for (let index = start; index < items.length; index += 1) {
+      visit(index + 1, [...selected, items[index]]);
+    }
+  };
+  visit(0, []);
+  return output;
+};
+var probabilityOfBacktestOverfitting = (performanceByVariant) => {
+  const blocks = Math.min(
+    ...performanceByVariant.map((performance) => performance.length)
+  );
+  if (performanceByVariant.length < 2 || blocks < 4) {
+    return { method: "CSCV", combinations: 0, probability: null };
+  }
+  if (performanceByVariant.every(
+    (performance) => performance.slice(0, blocks).every((value, index) => value === performanceByVariant[0][index])
+  )) {
+    return { method: "CSCV", combinations: 0, probability: null };
+  }
+  const usableBlocks = blocks % 2 === 0 ? blocks : blocks - 1;
+  const blockIndexes = Array.from(
+    { length: usableBlocks },
+    (_, index) => index
+  );
+  const splits = combinations(blockIndexes, usableBlocks / 2);
+  let belowMedian = 0;
+  for (const inSample of splits) {
+    const inSet = new Set(inSample);
+    const outSample = blockIndexes.filter((index) => !inSet.has(index));
+    const inScores = performanceByVariant.map(
+      (performance) => inSample.reduce((sum, index) => sum + performance[index], 0)
+    );
+    const selected = inScores.indexOf(Math.max(...inScores));
+    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;
+  }
+  return {
+    method: "CSCV",
+    combinations: splits.length,
+    probability: splits.length ? belowMedian / splits.length : null
+  };
+};
+
+// src/lib/coreResearch/comparison.ts
+var selectCohort2 = (trades, cohort) => cohort === "ALL" ? trades : trades.filter((trade) => trade.direction === cohort);
+var groupBySetup = (trades) => {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const trade of trades) {
+    const bucket = grouped.get(trade.setupIdentity) ?? [];
+    bucket.push(trade);
+    grouped.set(trade.setupIdentity, bucket);
+  }
+  for (const bucket of grouped.values()) {
+    bucket.sort(
+      (left, right) => left.signalTimestamp - right.signalTimestamp || left.entryTimestamp - right.entryTimestamp || left.exitTimestamp - right.exitTimestamp
+    );
+  }
+  return grouped;
+};
+var evaluateRules = (params) => {
+  let passed = true;
+  for (const rule of params.rules) {
+    const evaluation = evaluateCoreResearchThresholdRule({
+      control: params.control,
+      candidate: params.candidate,
+      rule
+    });
+    if (!evaluation.passed) {
+      passed = false;
+      params.failedRules.push({
+        scope: params.scope,
+        metric: rule.metric,
+        expected: `${rule.comparison} ${rule.relativeToControl === false ? "" : "control "}${rule.value ?? 0}`.trim(),
+        actual: evaluation.actual,
+        control: evaluation.control
+      });
+    }
+  }
+  return passed;
+};
+var evaluateSelection = (params) => {
+  const { spec, cohorts } = params;
+  const target = spec.hypothesis.target;
+  const nonTarget = target === "LONG" ? "SHORT" : target === "SHORT" ? "LONG" : null;
+  const failedRules = [];
+  const warnings = [];
+  const targetMetrics = cohorts[target].candidate;
+  let targetPassed = true;
+  if (targetMetrics.trades < spec.selection.minimumTrades) {
+    targetPassed = false;
+    failedRules.push({
+      scope: target,
+      metric: "trades",
+      expected: `>= ${spec.selection.minimumTrades}`,
+      actual: targetMetrics.trades,
+      control: cohorts[target].control.trades
+    });
+  }
+  if (targetMetrics.cadencePerDay == null || targetMetrics.cadencePerDay < spec.selection.minimumCadencePerDay) {
+    targetPassed = false;
+    failedRules.push({
+      scope: target,
+      metric: "cadencePerDay",
+      expected: `>= ${spec.selection.minimumCadencePerDay}`,
+      actual: targetMetrics.cadencePerDay,
+      control: cohorts[target].control.cadencePerDay
+    });
+  }
+  targetPassed = evaluateRules({
+    scope: target,
+    control: cohorts[target].control,
+    candidate: targetMetrics,
+    rules: spec.selection.targetRules,
+    failedRules
+  }) && targetPassed;
+  let aggregatePassed = evaluateRules({
+    scope: "ALL",
+    control: cohorts.ALL.control,
+    candidate: cohorts.ALL.candidate,
+    rules: spec.selection.aggregateRules,
+    failedRules
+  });
+  const maxDdRegression = spec.selection.maximumPortfolioDrawdownRegressionPct;
+  if (maxDdRegression != null) {
+    const controlDd = cohorts.ALL.control.realizedMaxDrawdown;
+    const allowed = controlDd * (1 + maxDdRegression / 100);
+    if (cohorts.ALL.candidate.realizedMaxDrawdown > allowed) {
+      aggregatePassed = false;
+      failedRules.push({
+        scope: "ALL",
+        metric: "realizedMaxDrawdown",
+        expected: `<= control + ${maxDdRegression}%`,
+        actual: cohorts.ALL.candidate.realizedMaxDrawdown,
+        control: controlDd
+      });
+    }
+  }
+  const nonTargetPassed = nonTarget ? evaluateRules({
+    scope: nonTarget,
+    control: cohorts[nonTarget].control,
+    candidate: cohorts[nonTarget].candidate,
+    rules: spec.selection.nonTargetRules,
+    failedRules
+  }) : true;
+  if (target !== "ALL") {
+    warnings.push(
+      `Direction-targeted verdict uses ${target}; aggregate portfolio guardrails remain independent.`
+    );
+  }
+  return {
+    target,
+    passed: targetPassed && aggregatePassed && nonTargetPassed,
+    targetPassed,
+    aggregatePassed,
+    nonTargetPassed,
+    failedRules,
+    warnings
+  };
+};
+var compareCoreResearchVariants = (params) => {
+  const { spec, control, candidate } = params;
+  const controlGrouped = groupBySetup(control.trades);
+  const candidateGrouped = groupBySetup(candidate.trades);
+  const setupKeys = /* @__PURE__ */ new Set([
+    ...controlGrouped.keys(),
+    ...candidateGrouped.keys()
+  ]);
+  const matchedPairs = [];
+  const controlOnly = [];
+  const candidateOnly = [];
+  for (const setupIdentity of [...setupKeys].sort()) {
+    const controlBucket = controlGrouped.get(setupIdentity) ?? [];
+    const candidateBucket = candidateGrouped.get(setupIdentity) ?? [];
+    const matched = Math.min(controlBucket.length, candidateBucket.length);
+    for (let index = 0; index < matched; index += 1) {
+      const controlTrade = controlBucket[index];
+      const candidateTrade = candidateBucket[index];
+      matchedPairs.push({
+        identity: `${setupIdentity}#${index + 1}`,
+        control: controlTrade,
+        candidate: candidateTrade,
+        pnlDelta: candidateTrade.netProfit - controlTrade.netProfit,
+        exitReasonChanged: candidateTrade.exitReason !== controlTrade.exitReason,
+        entryTimestampDeltaMs: candidateTrade.entryTimestamp - controlTrade.entryTimestamp,
+        exitTimestampDeltaMs: candidateTrade.exitTimestamp - controlTrade.exitTimestamp
+      });
+    }
+    controlOnly.push(...controlBucket.slice(matched));
+    candidateOnly.push(...candidateBucket.slice(matched));
+  }
+  const periodDays = (spec.window.end - spec.window.start) / (24 * 60 * 60 * 1e3);
+  const cohorts = Object.fromEntries(
+    CORE_RESEARCH_COHORTS.map((cohort) => {
+      const controlMetrics = summarizeCoreResearchTrades(
+        selectCohort2(control.trades, cohort),
+        periodDays
+      );
+      const candidateMetrics = summarizeCoreResearchTrades(
+        selectCohort2(candidate.trades, cohort),
+        periodDays
+      );
+      const matched = matchedPairs.filter(
+        (pair) => cohort === "ALL" || pair.control.direction === cohort
+      );
+      return [
+        cohort,
+        {
+          control: controlMetrics,
+          candidate: candidateMetrics,
+          delta: {
+            pnl: candidateMetrics.pnl - controlMetrics.pnl,
+            pnlPerTrade: candidateMetrics.pnlPerTrade == null || controlMetrics.pnlPerTrade == null ? null : candidateMetrics.pnlPerTrade - controlMetrics.pnlPerTrade,
+            profitFactor: candidateMetrics.profitFactor == null || controlMetrics.profitFactor == null ? null : candidateMetrics.profitFactor - controlMetrics.profitFactor,
+            winRatePct: candidateMetrics.winRatePct == null || controlMetrics.winRatePct == null ? null : candidateMetrics.winRatePct - controlMetrics.winRatePct,
+            realizedMaxDrawdown: candidateMetrics.realizedMaxDrawdown - controlMetrics.realizedMaxDrawdown,
+            cadencePerDay: candidateMetrics.cadencePerDay == null || controlMetrics.cadencePerDay == null ? null : candidateMetrics.cadencePerDay - controlMetrics.cadencePerDay
+          },
+          matchedPnlDelta: matched.reduce(
+            (sum, pair) => sum + pair.pnlDelta,
+            0
+          ),
+          controlOnlyPnl: selectCohort2(controlOnly, cohort).reduce(
+            (sum, trade) => sum + trade.netProfit,
+            0
+          ),
+          candidateOnlyPnl: selectCohort2(candidateOnly, cohort).reduce(
+            (sum, trade) => sum + trade.netProfit,
+            0
+          )
+        }
+      ];
+    })
+  );
+  return {
+    controlId: control.variant.id,
+    candidateId: candidate.variant.id,
+    matched: matchedPairs.length,
+    controlOnly: controlOnly.length,
+    candidateOnly: candidateOnly.length,
+    matchedIdentityPctOfControl: control.trades.length > 0 ? matchedPairs.length / control.trades.length * 100 : null,
+    matchedPairs,
+    cohorts,
+    bootstrap: calendarClusterBootstrap({
+      control: control.trades,
+      candidate: candidate.trades,
+      clusterDays: spec.robustness.clusterDays,
+      iterations: spec.robustness.bootstrapIterations,
+      confidenceLevel: spec.robustness.confidenceLevel,
+      seed: `${spec.researchId}:${candidate.variant.id}`,
+      start: spec.window.start,
+      end: spec.window.end
+    }),
+    selection: evaluateSelection({ spec, cohorts })
+  };
+};
+
+// 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 asRecord = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : null;
+var finiteNumber = (value, field) => {
+  const numeric = Number(value);
+  if (!Number.isFinite(numeric)) throw new Error(`${field} must be finite`);
+  return numeric;
+};
+var normalizeDirection = (value) => {
+  const direction = String(value ?? "").toUpperCase();
+  if (direction !== "LONG" && direction !== "SHORT") {
+    throw new Error(`Unsupported trade direction: ${direction || "<empty>"}`);
+  }
+  return direction;
+};
+var findStrategySetupIdentity = (value, depth = 0) => {
+  if (depth > 5) return null;
+  const record = asRecord(value);
+  if (!record) return null;
+  for (const key of ["setupIdentity", "setupId", "patternId", "candidateId"]) {
+    const candidate = record[key];
+    if (typeof candidate === "string" && candidate.trim() || typeof candidate === "number" && Number.isFinite(candidate)) {
+      return `${key}:${String(candidate)}`;
+    }
+  }
+  for (const [key, nested] of Object.entries(record)) {
+    if (/context|signal|setup|pattern|candidate|strategy/i.test(key) && nested != null) {
+      const found = findStrategySetupIdentity(nested, depth + 1);
+      if (found) return found;
+    }
+  }
+  return null;
+};
+var classifyBreadth = (baseContext) => {
+  const relative = asRecord(baseContext?.relative);
+  const btcAlt = asRecord(relative?.btcAltRegime);
+  const gateFeatures = asRecord(baseContext?.gateFeatures);
+  const gateRelative = asRecord(gateFeatures?.relative);
+  const regime = String(btcAlt?.regime ?? gateRelative?.btcAltRegime ?? "");
+  if (regime === "risk_on" || regime === "alt_lead") return "risk_on";
+  if (regime === "risk_off") return "risk_off";
+  if (["mixed", "neutral", "btc_lead"].includes(regime))
+    return "mixed";
+  const breadth = asRecord(relative?.marketBreadth);
+  const equalWeightedReturn = Number(
+    breadth?.equalWeightedReturn ?? gateRelative?.marketBreadthReturn
+  );
+  const aboveMa50 = Number(breadth?.pctAboveMa50);
+  if (Number.isFinite(equalWeightedReturn) || Number.isFinite(aboveMa50)) {
+    if (equalWeightedReturn > 0 && (!Number.isFinite(aboveMa50) || aboveMa50 >= 50)) {
+      return "risk_on";
+    }
+    if (equalWeightedReturn < 0 && (!Number.isFinite(aboveMa50) || aboveMa50 < 50)) {
+      return "risk_off";
+    }
+    return "mixed";
+  }
+  return "unknown";
+};
+var classifyDerivatives = (baseContext) => {
+  const derivatives = asRecord(baseContext?.derivatives);
+  const targetContext = asRecord(derivatives?.targetContext);
+  const summary = asRecord(targetContext?.summary) ?? asRecord(derivatives?.summary);
+  const pressure = String(summary?.pressure ?? "");
+  if (pressure === "crowded_long" || pressure === "crowded_short") {
+    return "crowded";
+  }
+  if (pressure === "long_flush" || pressure === "short_flush") {
+    return "supportive";
+  }
+  if (pressure === "neutral") return "neutral";
+  return "unknown";
+};
+var resolveCoreResearchRegime = (row) => {
+  const additional = asRecord(row.payload?.additionalIndicators);
+  const baseContext = asRecord(additional?.baseContext);
+  const regime = asRecord(baseContext?.regime);
+  const trendContext = asRecord(regime?.trend);
+  const volatilityContext = asRecord(regime?.volatility);
+  const trendValue = String(trendContext?.bias ?? "unknown");
+  const volatilityValue = String(volatilityContext?.state ?? "unknown");
+  const trend = ["bull", "bear", "neutral"].includes(trendValue) ? trendValue : "unknown";
+  const volatility = ["compressed", "normal", "expanded"].includes(
+    volatilityValue
+  ) ? volatilityValue : "unknown";
+  const breadth = classifyBreadth(baseContext);
+  const derivatives = classifyDerivatives(baseContext);
+  return {
+    trend,
+    volatility,
+    breadth,
+    derivatives,
+    key: [trend, volatility, breadth, derivatives].join("|")
+  };
+};
+var normalizeCompletedTrade = (params) => {
+  const { filePath, fileSha256, lineNumber, row } = params;
+  const result = row.tradeResult;
+  if (!result) return null;
+  const signalTimestamp = finiteNumber(row.timestamp, "row.timestamp");
+  const strategyIdentity = findStrategySetupIdentity(
+    row.payload?.additionalIndicators
+  );
+  const explicitIdentity = row.research?.setupIdentity?.trim() || null;
+  const direction = normalizeDirection(row.direction ?? result.direction);
+  const signalId = String(row.signalId ?? result.signalId ?? "").trim();
+  if (!signalId) throw new Error("signalId must be non-empty");
+  const setupIdentity = explicitIdentity ? explicitIdentity : strategyIdentity ? `${row.strategyName}|${row.symbol}|${direction}|${strategyIdentity}` : `${row.strategyName}|${row.symbol}|${direction}|${signalTimestamp}`;
+  return {
+    sourceFile: filePath,
+    sourceLine: lineNumber,
+    sourceSha256: fileSha256,
+    runId: row.backtestRunId ?? null,
+    configId: row.configId?.trim() || "<missing-config-id>",
+    signalId,
+    setupIdentity,
+    setupIdentitySource: explicitIdentity ? "research.setupIdentity" : strategyIdentity ? "strategy-context" : "signal-time-fallback",
+    strategy: row.strategyName,
+    symbol: row.symbol,
+    direction,
+    signalTimestamp,
+    entryTimestamp: finiteNumber(result.entryTimestamp, "entryTimestamp"),
+    exitTimestamp: finiteNumber(result.exitTimestamp, "exitTimestamp"),
+    entryPrice: finiteNumber(result.entryPrice, "entryPrice"),
+    exitPrice: result.exitPrice == null ? null : finiteNumber(result.exitPrice, "exitPrice"),
+    qty: finiteNumber(result.qty, "qty"),
+    netProfit: finiteNumber(result.netProfit, "netProfit"),
+    grossProfit: finiteNumber(result.grossProfit, "grossProfit"),
+    totalFee: finiteNumber(result.totalFee, "totalFee"),
+    totalSlippageCost: finiteNumber(
+      result.totalSlippageCost,
+      "totalSlippageCost"
+    ),
+    exitReason: result.exitReason,
+    regime: resolveCoreResearchRegime(row)
+  };
+};
+var completedTradeIdentity = (trade) => [trade.runId ?? "", trade.configId, trade.signalId, trade.symbol].join("|");
+var compareText = (left, right) => left < right ? -1 : left > right ? 1 : 0;
+var compareTrades = (left, right) => left.exitTimestamp - right.exitTimestamp || compareText(left.symbol, right.symbol) || compareText(left.direction, right.direction) || compareText(left.signalId, right.signalId) || compareText(left.sourceFile, right.sourceFile) || left.sourceLine - right.sourceLine;
+var readCoreResearchVariant = async (variant) => {
+  const trades = [];
+  const sources = [];
+  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 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 fileTrades = [];
+    let lineNumber = 0;
+    let rows = 0;
+    let rowsForDifferentRun = 0;
+    let rowsWithoutTradeResult = 0;
+    let selectedTrades = 0;
+    for await (const line of lines) {
+      lineNumber += 1;
+      if (!line.trim()) continue;
+      rows += 1;
+      let row;
+      try {
+        row = JSON.parse(line);
+      } catch (error) {
+        throw new Error(
+          `${filePath}:${lineNumber} contains invalid JSON: ${String(error)}`
+        );
+      }
+      if (variant.runId && row.backtestRunId !== variant.runId) {
+        rowsForDifferentRun += 1;
+        continue;
+      }
+      const trade = normalizeCompletedTrade({
+        filePath,
+        fileSha256: "",
+        lineNumber,
+        row
+      });
+      if (!trade) {
+        rowsWithoutTradeResult += 1;
+        continue;
+      }
+      selectedTrades += 1;
+      const identity = completedTradeIdentity(trade);
+      const existing = seen.get(identity);
+      if (existing) {
+        if (existing.netProfit !== trade.netProfit || existing.exitTimestamp !== trade.exitTimestamp || existing.direction !== trade.direction) {
+          throw new Error(
+            `Conflicting completed trades share identity ${identity}`
+          );
+        }
+        duplicateRowsDropped += 1;
+        continue;
+      }
+      seen.set(identity, trade);
+      trades.push(trade);
+      fileTrades.push(trade);
+    }
+    const fileSha256 = hash.digest("hex");
+    for (const trade of fileTrades) trade.sourceSha256 = fileSha256;
+    sources.push({
+      path: filePath,
+      sha256: fileSha256,
+      rows,
+      selectedTrades,
+      rowsForDifferentRun,
+      rowsWithoutTradeResult
+    });
+  }
+  return {
+    variant,
+    files: sources,
+    duplicateRowsDropped,
+    trades: trades.sort(compareTrades)
+  };
+};
+
+// src/lib/coreResearch/report.ts
+var escapeHtml = (value) => String(value ?? "").replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&#039;");
+var format = (value, digits = 2) => value == null || !Number.isFinite(value) ? "n/a" : value.toFixed(digits);
+var tone = (value) => value == null ? "" : value > 0 ? "positive" : value < 0 ? "negative" : "";
+var metricRows = (variant, window) => ["ALL", "LONG", "SHORT"].map((cohort) => {
+  const metrics = window.cohorts[cohort];
+  return `<tr><td>${escapeHtml(variant.variant.label)}</td><td>${escapeHtml(window.label)}</td><td>${cohort}</td><td>${metrics.trades}</td><td class="${tone(metrics.pnl)}">${format(metrics.pnl)}</td><td class="${tone(metrics.pnlPerTrade)}">${format(metrics.pnlPerTrade, 4)}</td><td>${format(metrics.profitFactor, 4)}</td><td>${format(metrics.winRatePct)}%</td><td>${format(metrics.realizedMaxDrawdown)}</td><td>${format(metrics.cadencePerDay, 3)}</td><td>${format(metrics.averageWin)}</td><td>${format(metrics.averageLoss)}</td><td>${format(metrics.payoffRatio, 3)}</td><td>${format(metrics.medianPnl)}</td><td>${format(metrics.pnlP05)}</td><td>${format(metrics.pnlP95)}</td><td>${format(metrics.medianHoldingHours, 2)}</td><td>${metrics.maximumConsecutiveLosses}</td></tr>`;
+}).join("");
+var equitySeries = (trades) => {
+  let equity = 0;
+  return orderCoreResearchTrades(trades).map((trade) => {
+    equity += trade.netProfit;
+    return { timestamp: trade.exitTimestamp, value: equity };
+  });
+};
+var drawdownSeries = (trades) => {
+  let equity = 0;
+  let peak = 0;
+  return orderCoreResearchTrades(trades).map((trade) => {
+    equity += trade.netProfit;
+    peak = Math.max(peak, equity);
+    return { timestamp: trade.exitTimestamp, value: peak - equity };
+  });
+};
+var MAX_CHART_POINTS = 1200;
+var downsampleCurve = (points) => {
+  if (points.length <= MAX_CHART_POINTS) return points;
+  const interior = points.slice(1, -1);
+  const bucketCount = Math.max(1, Math.floor((MAX_CHART_POINTS - 2) / 2));
+  const bucketSize = Math.ceil(interior.length / bucketCount);
+  const selected = [points[0]];
+  for (let start = 0; start < interior.length; start += bucketSize) {
+    const bucket = interior.slice(start, start + bucketSize);
+    if (!bucket.length) continue;
+    const minimum = bucket.reduce(
+      (best, point) => point.value < best.value ? point : best
+    );
+    const maximum = bucket.reduce(
+      (best, point) => point.value > best.value ? point : best
+    );
+    const extrema = minimum === maximum ? [minimum] : [minimum, maximum];
+    selected.push(
+      ...extrema.sort((left, right) => left.timestamp - right.timestamp)
+    );
+  }
+  selected.push(points.at(-1));
+  return selected;
+};
+var buildCurveSvg = (tradesByVariant, cohort, curve) => {
+  const colors = ["#78dce8", "#ff6188", "#a9dc76", "#ffd866", "#ab9df2"];
+  const series = [...tradesByVariant.entries()].map(([id, trades], index) => ({
+    id,
+    color: colors[index % colors.length],
+    points: downsampleCurve(
+      (curve === "equity" ? equitySeries : drawdownSeries)(
+        cohort === "ALL" ? trades : trades.filter((trade) => trade.direction === cohort)
+      )
+    )
+  }));
+  const points = series.flatMap((entry) => entry.points);
+  if (!points.length) return "<p>No completed trades.</p>";
+  const minTimestamp = Math.min(...points.map((point) => point.timestamp));
+  const maxTimestamp = Math.max(...points.map((point) => point.timestamp));
+  const minValue = Math.min(0, ...points.map((point) => point.value));
+  const maxValue = Math.max(0, ...points.map((point) => point.value));
+  const width = 960;
+  const height = 300;
+  const padding = 30;
+  const x = (timestamp) => padding + (timestamp - minTimestamp) / Math.max(1, maxTimestamp - minTimestamp) * (width - 2 * padding);
+  const y = (value) => height - padding - (value - minValue) / Math.max(1e-9, maxValue - minValue) * (height - 2 * padding);
+  const zeroY = y(0);
+  return `<svg viewBox="0 0 ${width} ${height}" role="img" aria-label="${cohort} ${curve}"><line x1="${padding}" x2="${width - padding}" y1="${zeroY}" y2="${zeroY}" class="zero"/>${series.map(
+    (entry) => `<polyline fill="none" stroke="${entry.color}" stroke-width="2" points="${entry.points.map((point) => `${x(point.timestamp).toFixed(1)},${y(point.value).toFixed(1)}`).join(" ")}"><title>${escapeHtml(entry.id)}</title></polyline>`
+  ).join(
+    ""
+  )}</svg><div class="legend">${series.map((entry) => `<span><i style="background:${entry.color}"></i>${escapeHtml(entry.id)}</span>`).join("")}</div>`;
+};
+var comparisonCards = (comparisons) => comparisons.map(
+  (comparison) => `<article class="card"><h3>${escapeHtml(comparison.candidateId)} vs ${escapeHtml(comparison.controlId)}</h3><p class="verdict ${comparison.selection.passed ? "positive" : "negative"}">${comparison.selection.passed ? "PASS selection" : "REJECT selection"}</p><dl><dt>Matched</dt><dd>${comparison.matched}</dd><dt>Control only</dt><dd>${comparison.controlOnly}</dd><dt>Candidate only</dt><dd>${comparison.candidateOnly}</dd><dt>Identity retained</dt><dd>${format(comparison.matchedIdentityPctOfControl)}%</dd><dt>Matched \u0394PnL</dt><dd>${format(comparison.cohorts.ALL.matchedPnlDelta)}</dd><dt>Removed control PnL</dt><dd>${format(comparison.cohorts.ALL.controlOnlyPnl)}</dd><dt>Added candidate PnL</dt><dd>${format(comparison.cohorts.ALL.candidateOnlyPnl)}</dd><dt>Aggregate \u0394PnL</dt><dd>${format(comparison.cohorts.ALL.delta.pnl)}</dd><dt>Aggregate \u0394DD</dt><dd>${format(comparison.cohorts.ALL.delta.realizedMaxDrawdown)}</dd><dt>Bootstrap P(\u0394&gt;0)</dt><dd>${format(comparison.bootstrap.probabilityPositive, 4)}</dd><dt>Holm p</dt><dd>${format(comparison.bootstrap.holmAdjustedPValue, 4)}</dd></dl><p>${comparison.selection.failedRules.length ? escapeHtml(comparison.selection.failedRules.map((rule) => `${rule.scope}.${rule.metric} ${rule.expected}`).join("; ")) : "All preregistered rules passed."}</p></article>`
+).join("");
+var regimeRows = (variants) => {
+  const keys = [
+    ...new Set(variants.flatMap((variant) => Object.keys(variant.regimes)))
+  ].sort();
+  return keys.flatMap(
+    (key) => variants.map((variant) => {
+      const metrics = variant.regimes[key]?.ALL;
+      return `<tr><td>${escapeHtml(key)}</td><td>${escapeHtml(variant.variant.label)}</td><td>${metrics?.trades ?? 0}</td><td class="${tone(metrics?.pnl ?? null)}">${format(metrics?.pnl ?? null)}</td><td>${format(metrics?.profitFactor ?? null, 3)}</td><td>${format(metrics?.winRatePct ?? null)}%</td></tr>`;
+    })
+  ).join("");
+};
+var traceRows = (variants) => variants.map(
+  (variant) => `<tr><td>${escapeHtml(variant.variant.label)}</td><td>${escapeHtml(variant.reconciliation.status)}</td><td>${escapeHtml(JSON.stringify(variant.setupIdentitySources))}</td><td>${escapeHtml(JSON.stringify(variant.traceFunnel.events))}</td><td>${escapeHtml(JSON.stringify(variant.traceFunnel.skipCounts))}</td><td>${escapeHtml(variant.latestSignalTimeRegime?.key ?? "n/a")}</td></tr>`
+).join("");
+var buildCoreResearchHtml = (params) => {
+  const { spec, result, tradesByVariant } = params;
+  const allRows = result.variants.flatMap(
+    (variant) => [variant.full, ...variant.terminal].map(
+      (window) => metricRows(variant, window)
+    )
+  ).join("");
+  const robustnessRows = result.variants.flatMap(
+    (variant) => [...variant.folds, ...variant.monthly].map(
+      (window) => metricRows(variant, window)
+    )
+  ).join("");
+  const costRows = result.variants.flatMap(
+    (variant) => variant.costStress.map((stress) => {
+      const metrics = stress.cohorts.ALL;
+      return `<tr><td>${escapeHtml(variant.variant.label)}</td><td>${stress.extraRoundTripBps}</td><td>${metrics.trades}</td><td class="${tone(metrics.pnl)}">${format(metrics.pnl)}</td><td>${format(metrics.pnlPerTrade, 4)}</td><td>${format(metrics.profitFactor, 4)}</td><td>${format(metrics.realizedMaxDrawdown)}</td></tr>`;
+    })
+  ).join("");
+  return `<!doctype html><html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1"><title>${escapeHtml(spec.researchId)}</title><style>:root{color-scheme:dark;--bg:#17171f;--panel:#22222d;--line:#3a3a49;--text:#f8f8f2;--muted:#a9a9b5;--good:#a9dc76;--bad:#ff6188}*{box-sizing:border-box}body{margin:0;background:var(--bg);color:var(--text);font:14px/1.45 ui-monospace,SFMono-Regular,Menlo,monospace}main{max-width:1240px;margin:auto;padding:28px}h1{font-size:30px}h2{margin-top:36px}.muted{color:var(--muted)}.grid{display:grid;grid-template-columns:repeat(auto-fit,minmax(280px,1fr));gap:14px}.card{background:var(--panel);border:1px solid var(--line);border-radius:10px;padding:16px}.positive{color:var(--good)}.negative{color:var(--bad)}dl{display:grid;grid-template-columns:1fr auto;gap:6px;margin:0}dt{color:var(--muted)}dd{margin:0}table{border-collapse:collapse;width:100%;font-size:12px;background:var(--panel)}th,td{padding:7px 9px;border:1px solid var(--line);text-align:right}th{text-align:center;position:sticky;top:0;background:#292936}td:nth-child(-n+3){text-align:left}.scroll{overflow:auto;max-height:600px}svg{width:100%;background:var(--panel);border:1px solid var(--line);border-radius:10px}.zero{stroke:#777;stroke-dasharray:4 4}.legend{display:flex;gap:16px;margin:7px}.legend i{display:inline-block;width:12px;height:3px;margin-right:6px;vertical-align:middle}.evidence{display:grid;grid-template-columns:repeat(auto-fit,minmax(180px,1fr));gap:8px}.evidence span{padding:9px;border:1px solid var(--line);border-radius:6px}</style></head><body><main><header><p class="muted">${escapeHtml(result.schema)} \xB7 ${escapeHtml(result.generatedAt)}</p><h1>${escapeHtml(spec.researchId)}</h1><p>${escapeHtml(spec.hypothesis.claim)}</p><p class="muted">Mechanism: ${escapeHtml(spec.hypothesis.mechanism)} \xB7 stage=${spec.stage} \xB7 target=${spec.hypothesis.target} \xB7 spec=${result.specSha256}</p></header><h2>Selection</h2><section class="grid">${comparisonCards(result.comparisons)}</section><h2>Evidence matrix</h2><section class="evidence">${Object.entries(
+    result.evidence
+  ).map(
+    ([key, value]) => `<span class="${value === "present" ? "positive" : "negative"}">${escapeHtml(key)}: ${value}</span>`
+  ).join(
+    ""
+  )}</section><h2>ALL equity</h2>${buildCurveSvg(tradesByVariant, "ALL", "equity")}<h2>ALL realized drawdown</h2>${buildCurveSvg(tradesByVariant, "ALL", "drawdown")}<h2>LONG equity</h2>${buildCurveSvg(tradesByVariant, "LONG", "equity")}<h2>LONG realized drawdown</h2>${buildCurveSvg(tradesByVariant, "LONG", "drawdown")}<h2>SHORT equity</h2>${buildCurveSvg(tradesByVariant, "SHORT", "equity")}<h2>SHORT realized drawdown</h2>${buildCurveSvg(tradesByVariant, "SHORT", "drawdown")}<h2>Fixed cohort metrics</h2><p class="muted">Avg PnL/trade = cohort PnL / cohort N. ALL drawdown is aggregate portfolio; LONG/SHORT drawdowns are side-only.</p><div class="scroll"><table><thead><tr><th>Variant</th><th>Window</th><th>Cohort</th><th>N</th><th>PnL</th><th>Avg PnL/trade</th><th>PF</th><th>WR</th><th>Realized DD</th><th>Cad/day</th><th>Avg win</th><th>Avg loss</th><th>Payoff</th><th>Median</th><th>P05</th><th>P95</th><th>Median hold h</th><th>Max loss streak</th></tr></thead><tbody>${allRows}</tbody></table></div><h2>Fold and monthly robustness</h2><div class="scroll"><table><thead><tr><th>Variant</th><th>Window</th><th>Cohort</th><th>N</th><th>PnL</th><th>Avg PnL/trade</th><th>PF</th><th>WR</th><th>Realized DD</th><th>Cad/day</th><th>Avg win</th><th>Avg loss</th><th>Payoff</th><th>Median</th><th>P05</th><th>P95</th><th>Median hold h</th><th>Max loss streak</th></tr></thead><tbody>${robustnessRows}</tbody></table></div><h2>Cost stress</h2><div class="scroll"><table><thead><tr><th>Variant</th><th>Extra round-trip bps</th><th>N</th><th>PnL</th><th>Avg PnL/trade</th><th>PF</th><th>Realized DD</th></tr></thead><tbody>${costRows}</tbody></table></div><h2>Signal-time market regimes</h2><div class="scroll"><table><thead><tr><th>Trend | Volatility | Breadth | Derivatives</th><th>Variant</th><th>N</th><th>PnL</th><th>PF</th><th>WR</th></tr></thead><tbody>${regimeRows(result.variants)}</tbody></table></div><h2>Trace funnel and reconciliation</h2><div class="scroll"><table><thead><tr><th>Variant</th><th>Reconcile</th><th>Setup identity source</th><th>Events</th><th>Top skips</th><th>Latest signal-time regime</th></tr></thead><tbody>${traceRows(result.variants)}</tbody></table></div><h2>Multiple testing / overfitting</h2><pre>${escapeHtml(JSON.stringify({ multipleTesting: result.multipleTesting, overfittingDiagnostics: result.overfittingDiagnostics }, null, 2))}</pre><h2>Lineage</h2><pre>${escapeHtml(JSON.stringify({ stage: spec.stage, universeSha256: spec.universe.sha256, lineage: spec.lineage ?? null, artifactHashes: result.artifactHashes }, null, 2))}</pre></main></body></html>`;
+};
+
+// src/lib/backtest/checkpoint.ts
+var import_node_crypto4 = require("crypto");
+var import_constants = require("@tradejs/core/constants");
+var import_redis = require("@tradejs/infra/redis");
+
+// src/lib/runFormatting.ts
+var import_date_fns = require("date-fns");
+var ListIt = require("list-it");
+
+// src/lib/backtest/checkpoint.ts
+var loadBacktestCheckpointResults = async ({
+  runId,
+  userName
+}) => (0, import_redis.getHashJsonValues)(
+  import_redis.redisKeys.backtestRunResults(userName, runId)
+);
+var loadBacktestRunManifest = async ({
+  runId,
+  userName
+}) => await (0, import_redis.getData)(
+  import_redis.redisKeys.backtestRun(userName, runId),
+  null
+);
+
+// src/lib/coreResearch/reconciliation.ts
+var finite = (value) => {
+  const numeric = Number(value);
+  return Number.isFinite(numeric) ? numeric : 0;
+};
+var reconcileCoreResearchVariant = async (params) => {
+  const { variant, exportMetrics } = params;
+  const exportSummary = {
+    trades: exportMetrics.trades,
+    wins: exportMetrics.wins,
+    losses: exportMetrics.losses,
+    pnl: exportMetrics.pnl
+  };
+  if (!variant.runId) {
+    return {
+      status: "not_requested",
+      runId: null,
+      manifestStatus: null,
+      plannedTests: null,
+      completedTests: null,
+      redis: null,
+      export: exportSummary,
+      delta: null,
+      pnlTolerance: null,
+      reasons: ["variant.runId is not set"]
+    };
+  }
+  const userName = params.userName ?? "root";
+  const [manifest, completed] = await Promise.all([
+    loadBacktestRunManifest({ runId: variant.runId, userName }),
+    loadBacktestCheckpointResults({ runId: variant.runId, userName })
+  ]);
+  if (!manifest) {
+    return {
+      status: "unavailable",
+      runId: variant.runId,
+      manifestStatus: null,
+      plannedTests: null,
+      completedTests: null,
+      redis: null,
+      export: exportSummary,
+      delta: null,
+      pnlTolerance: null,
+      reasons: ["backtest manifest is unavailable"]
+    };
+  }
+  const redis = completed.reduce(
+    (summary, envelope) => {
+      const stat = envelope.result.stat;
+      summary.trades += finite(stat.orders);
+      summary.wins += finite(stat.wins);
+      summary.losses += finite(stat.losses);
+      summary.pnl += finite(stat.netProfit ?? stat.profit);
+      return summary;
+    },
+    { trades: 0, wins: 0, losses: 0, pnl: 0 }
+  );
+  const delta = {
+    trades: exportSummary.trades - redis.trades,
+    wins: exportSummary.wins - redis.wins,
+    losses: exportSummary.losses - redis.losses,
+    pnl: exportSummary.pnl - redis.pnl
+  };
+  const pnlTolerance = completed.length * 5e-3 + 1e-9;
+  const reasons = [];
+  if (manifest.status !== "completed") {
+    reasons.push(`manifest status is ${manifest.status}`);
+  }
+  if (manifest.window.start !== params.spec.window.start || manifest.window.end !== params.spec.window.end) {
+    reasons.push("manifest window does not match the preregistered window");
+  }
+  if (manifest.config !== variant.configName) {
+    reasons.push(
+      `manifest config ${manifest.config} does not match ${variant.configName}`
+    );
+  }
+  if (manifest.connectorName !== params.spec.execution.connector) {
+    reasons.push(
+      "manifest connector does not match the preregistered connector"
+    );
+  }
+  if (String(manifest.interval) !== String(params.spec.execution.interval)) {
+    reasons.push("manifest interval does not match the preregistered interval");
+  }
+  if (!manifest.flags.ai) {
+    reasons.push("manifest did not enable raw AI dataset transport");
+  }
+  if (completed.length !== manifest.testSuite.length) {
+    reasons.push(
+      `checkpoint completion is ${completed.length}/${manifest.testSuite.length}`
+    );
+  }
+  const manifestSymbols = [
+    ...new Set(manifest.testSuite.map((test) => test.symbol))
+  ];
+  if (manifest.testSuite.length !== params.spec.universe.symbols.length || sha256Json(manifestSymbols) !== params.spec.universe.sha256) {
+    reasons.push(
+      "manifest test suite does not match the frozen ordered universe"
+    );
+  }
+  if (manifest.testSuite.some(
+    (test) => test.strategyName !== params.spec.strategy
+  )) {
+    reasons.push("manifest includes a different strategy");
+  }
+  const configIds = new Set(
+    completed.map(
+      (envelope) => envelope.result.test.configId?.trim() || "<missing-config-id>"
+    )
+  );
+  if (configIds.size !== 1) {
+    reasons.push(
+      `variant run must be isolated to one configId, found ${configIds.size}`
+    );
+  }
+  const resolvedConfigHashes = new Set(
+    completed.map(
+      (envelope) => sha256Json(envelope.result.test.strategyConfig ?? {})
+    )
+  );
+  if (resolvedConfigHashes.size !== 1 || !resolvedConfigHashes.has(variant.configSha256)) {
+    reasons.push(
+      "executed resolved strategy config does not match the preregistered config SHA"
+    );
+  }
+  if (delta.trades !== 0 || delta.wins !== 0 || delta.losses !== 0) {
+    reasons.push("export N/W/L does not match Redis result.stat");
+  }
+  if (Math.abs(delta.pnl) > pnlTolerance) {
+    reasons.push(
+      `export PnL delta ${delta.pnl} exceeds tolerance ${pnlTolerance}`
+    );
+  }
+  return {
+    status: reasons.length ? "mismatch" : "match",
+    runId: variant.runId,
+    manifestStatus: manifest.status,
+    plannedTests: manifest.testSuite.length,
+    completedTests: completed.length,
+    redis,
+    export: exportSummary,
+    delta,
+    pnlTolerance,
+    reasons
+  };
+};
+
+// src/lib/coreResearch/selection.ts
+var applyCoreResearchRobustnessGuardrails = (params) => {
+  const { spec, analyses, comparisons } = params;
+  const byVariantId = new Map(
+    analyses.map((analysis) => [analysis.variant.id, analysis])
+  );
+  const maximumHolmPValue = spec.selection.maximumHolmPValue;
+  for (const comparison of comparisons) {
+    if (maximumHolmPValue != null) {
+      const adjusted = comparison.bootstrap.holmAdjustedPValue;
+      if (adjusted == null || adjusted > maximumHolmPValue) {
+        comparison.selection.passed = false;
+        comparison.selection.targetPassed = false;
+        comparison.selection.warnings.push(
+          `Holm-adjusted p-value ${adjusted ?? "n/a"} exceeds ${maximumHolmPValue}`
+        );
+      }
+    }
+    const controlAnalysis = byVariantId.get(comparison.controlId);
+    const candidateAnalysis = byVariantId.get(comparison.candidateId);
+    const required2 = [
+      controlAnalysis?.reconciliation,
+      candidateAnalysis?.reconciliation
+    ].filter((value) => value?.runId);
+    if (required2.some((value) => value?.status !== "match")) {
+      comparison.selection.passed = false;
+      comparison.selection.aggregatePassed = false;
+      comparison.selection.warnings.push(
+        "Run-scoped Redis/export reconciliation failed; selection is invalid."
+      );
+    }
+    if (!candidateAnalysis || !controlAnalysis) continue;
+    const target = spec.hypothesis.target;
+    const underpoweredFolds = candidateAnalysis.folds.filter(
+      (window) => window.cohorts[target].trades < spec.robustness.minimumFoldTrades
+    );
+    if (underpoweredFolds.length) {
+      comparison.selection.passed = false;
+      comparison.selection.targetPassed = false;
+      comparison.selection.warnings.push(
+        `${underpoweredFolds.length}/${candidateAnalysis.folds.length} target folds have fewer than ${spec.robustness.minimumFoldTrades} trades`
+      );
+    }
+    const minimumPositiveFoldPct = spec.selection.minimumPositiveFoldPct;
+    if (minimumPositiveFoldPct != null) {
+      const positiveFoldPct = candidateAnalysis.folds.length ? candidateAnalysis.folds.filter(
+        (window) => window.cohorts[target].pnl > 0
+      ).length / candidateAnalysis.folds.length * 100 : 0;
+      if (positiveFoldPct < minimumPositiveFoldPct) {
+        comparison.selection.passed = false;
+        comparison.selection.targetPassed = false;
+        comparison.selection.warnings.push(
+          `Positive target folds ${positiveFoldPct.toFixed(2)}% < ${minimumPositiveFoldPct}%`
+        );
+      }
+    }
+    for (const candidateWindow of candidateAnalysis.terminal) {
+      const controlWindow = controlAnalysis.terminal.find(
+        (window) => window.label === candidateWindow.label
+      );
+      if (!controlWindow) continue;
+      const minimumTerminalTrades = Math.ceil(
+        candidateWindow.periodDays * spec.selection.minimumCadencePerDay
+      );
+      if (candidateWindow.cohorts[target].trades < minimumTerminalTrades) {
+        comparison.selection.passed = false;
+        comparison.selection.targetPassed = false;
+        comparison.selection.warnings.push(
+          `${candidateWindow.label} ${target} has fewer than ${minimumTerminalTrades} trades`
+        );
+      }
+      for (const rule of spec.selection.terminalRules ?? []) {
+        if (!evaluateCoreResearchThresholdRule({
+          control: controlWindow.cohorts[target],
+          candidate: candidateWindow.cohorts[target],
+          rule
+        }).passed) {
+          comparison.selection.passed = false;
+          comparison.selection.targetPassed = false;
+          comparison.selection.warnings.push(
+            `${candidateWindow.label} ${target}.${rule.metric} failed`
+          );
+        }
+      }
+    }
+    for (const candidateStress of candidateAnalysis.costStress) {
+      const controlStress = controlAnalysis.costStress.find(
+        (stress) => stress.extraRoundTripBps === candidateStress.extraRoundTripBps
+      );
+      if (!controlStress) continue;
+      for (const rule of spec.selection.costStressRules ?? []) {
+        if (!evaluateCoreResearchThresholdRule({
+          control: controlStress.cohorts[target],
+          candidate: candidateStress.cohorts[target],
+          rule
+        }).passed) {
+          comparison.selection.passed = false;
+          comparison.selection.targetPassed = false;
+          comparison.selection.warnings.push(
+            `cost+${candidateStress.extraRoundTripBps}bps ${target}.${rule.metric} failed`
+          );
+        }
+      }
+    }
+  }
+};
+
+// src/lib/coreResearch/trace.ts
+var import_promises3 = __toESM(require("fs/promises"));
+var import_node_path4 = __toESM(require("path"));
+var summarizeCoreResearchTrace = async (filePaths = []) => {
+  const events = {};
+  const skipCounts = {};
+  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;
+        }
+      }
+    }
+  }
+  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)
+      )
+    )
+  };
+};
+
+// src/lib/coreResearch/orchestrator.ts
+var summarizeSupplementalFiles = async (params) => {
+  const loaded = await readCoreResearchVariant({
+    ...params.variant,
+    id: params.id,
+    files: params.files,
+    runId: void 0,
+    command: void 0
+  });
+  return summarizeCoreResearchWindow({
+    trades: loaded.trades,
+    label: params.id,
+    start: params.start,
+    end: params.end
+  });
+};
+var analyzeCoreResearchPrepared = async (spec, options = {}) => {
+  const prepared = options.prepared ?? await prepareCoreResearch(spec);
+  const { paths, specSha256 } = prepared;
+  if (prepared.manifest.status === "completed") {
+    throw new Error(
+      `Research ${spec.researchId} is already completed and immutable; use verify or create a new researchId`
+    );
+  }
+  await appendCoreResearchLedger({
+    ledgerPath: paths.ledgerPath,
+    researchId: spec.researchId,
+    event: "analysis_started",
+    specSha256,
+    hypothesisFamily: spec.hypothesis.family,
+    hypothesesInRecord: spec.variants.filter(
+      (variant) => variant.role === "candidate"
+    ).length
+  });
+  const analysisSpec = {
+    ...spec,
+    variants: options.variants ?? spec.variants
+  };
+  const loaded = await Promise.all(
+    analysisSpec.variants.map(readCoreResearchVariant)
+  );
+  const windowed = loaded.map((entry) => ({
+    ...entry,
+    trades: entry.trades.filter(
+      (trade) => trade.exitTimestamp >= spec.window.start && trade.exitTimestamp < spec.window.end
+    )
+  }));
+  const periodDays = (spec.window.end - spec.window.start) / DAY_MS;
+  const analyses = await Promise.all(
+    windowed.map(async (entry) => ({
+      variant: entry.variant,
+      files: entry.files,
+      duplicateRowsDropped: entry.duplicateRowsDropped,
+      setupIdentitySources: entry.trades.reduce(
+        (summary, trade) => {
+          summary[trade.setupIdentitySource] += 1;
+          return summary;
+        },
+        {
+          "research.setupIdentity": 0,
+          "strategy-context": 0,
+          "signal-time-fallback": 0
+        }
+      ),
+      full: summarizeCoreResearchWindow({
+        trades: entry.trades,
+        label: "full",
+        start: spec.window.start,
+        end: spec.window.end
+      }),
+      terminal: buildTerminalWindows({
+        trades: entry.trades,
+        end: spec.window.end,
+        terminalDays: spec.window.terminalDays
+      }),
+      folds: buildEqualTimeFolds({
+        trades: entry.trades,
+        start: spec.window.start,
+        end: spec.window.end,
+        folds: spec.window.folds
+      }),
+      monthly: buildMonthlyWindows({
+        trades: entry.trades,
+        start: spec.window.start,
+        end: spec.window.end
+      }),
+      regimes: buildRegimeMetrics(entry.trades, periodDays),
+      costStress: buildCostStress({
+        trades: entry.trades,
+        periodDays,
+        extraRoundTripBps: spec.robustness.costStressBps
+      }),
+      traceFunnel: await summarizeCoreResearchTrace(entry.variant.traceFiles),
+      latestSignalTimeRegime: entry.trades.length ? {
+        ...[...entry.trades].sort(
+          (left, right) => right.signalTimestamp - left.signalTimestamp
+        )[0].regime,
+        timestamp: Math.max(
+          ...entry.trades.map((trade) => trade.signalTimestamp)
+        ),
+        lagToWindowEndMs: spec.window.end - Math.max(...entry.trades.map((trade) => trade.signalTimestamp))
+      } : null,
+      reconciliation: await reconcileCoreResearchVariant({
+        variant: entry.variant,
+        spec,
+        exportMetrics: summarizeCoreResearchWindow({
+          trades: entry.trades,
+          label: "full",
+          start: spec.window.start,
+          end: spec.window.end
+        }).cohorts.ALL
+      }),
+      supplemental: {
+        coldStart: Object.fromEntries(
+          await Promise.all(
+            Object.entries(entry.variant.coldStartFiles ?? {}).map(
+              async ([label, files]) => [
+                label,
+                await summarizeSupplementalFiles({
+                  variant: entry.variant,
+                  files,
+                  id: `${entry.variant.id}-cold-${label}`,
+                  start: spec.window.start,
+                  end: spec.window.end
+                })
+              ]
+            )
+          )
+        ),
+        stress: Object.fromEntries(
+          await Promise.all(
+            Object.entries(entry.variant.stressFiles ?? {}).map(
+              async ([label, files]) => [
+                label,
+                await summarizeSupplementalFiles({
+                  variant: entry.variant,
+                  files,
+                  id: `${entry.variant.id}-stress-${label}`,
+                  start: spec.window.start,
+                  end: spec.window.end
+                })
+              ]
+            )
+          )
+        ),
+        confirmation: entry.variant.confirmationFiles?.length ? await summarizeSupplementalFiles({
+          variant: entry.variant,
+          files: entry.variant.confirmationFiles,
+          id: `${entry.variant.id}-confirmation`,
+          start: spec.window.start,
+          end: spec.window.end
+        }) : null
+      }
+    }))
+  );
+  const control = windowed.find((entry) => entry.variant.role === "control");
+  if (!control) throw new Error("Core research control variant was not loaded");
+  const comparisons = windowed.filter((entry) => entry.variant.role === "candidate").map(
+    (candidate) => compareCoreResearchVariants({ spec: analysisSpec, control, candidate })
+  );
+  const familyHypotheses = (await readCoreResearchLedger(paths.ledgerPath)).filter((record) => record.hypothesisFamily === spec.hypothesis.family).reduce(
+    (sum, record) => record.event === "prepared" ? sum + record.hypothesesInRecord : sum,
+    0
+  );
+  applyHolmCorrection(
+    comparisons.map((comparison) => comparison.bootstrap),
+    Math.max(comparisons.length, familyHypotheses)
+  );
+  applyCoreResearchRobustnessGuardrails({ spec, analyses, comparisons });
+  const evidence = {
+    screen: spec.stage === "screen" ? "present" : "missing",
+    isolatedLong: spec.stage === "isolated_long" ? "present" : "missing",
+    terminals: spec.window.terminalDays.length ? "present" : "missing",
+    folds: spec.window.folds >= 2 ? "present" : "missing",
+    coldStart: analysisSpec.variants.every(
+      (variant) => Object.keys(variant.coldStartFiles ?? {}).length > 0
+    ) ? "present" : "missing",
+    costStress: spec.robustness.costStressBps.length ? "present" : "missing",
+    delayStress: analysisSpec.variants.every(
+      (variant) => Object.keys(variant.stressFiles ?? {}).length > 0
+    ) ? "present" : "missing",
+    fastNonFast: analysisSpec.variants.every(
+      (variant) => (variant.confirmationFiles?.length ?? 0) > 0
+    ) ? "present" : "missing",
+    runtimeParity: analysisSpec.variants.every(
+      (variant) => (variant.runtimeParityFiles?.length ?? 0) > 0
+    ) ? "present" : "missing"
+  };
+  const primarySourceHashes = Object.fromEntries(
+    analyses.flatMap(
+      (analysis) => analysis.files.map((file) => [
+        import_node_path5.default.relative(paths.researchDir, file.path),
+        file.sha256
+      ])
+    )
+  );
+  const supplementalSourcePaths = [
+    ...new Set(
+      analysisSpec.variants.flatMap((variant) => [
+        ...variant.traceFiles ?? [],
+        ...variant.confirmationFiles ?? [],
+        ...variant.runtimeParityFiles ?? [],
+        ...Object.values(variant.coldStartFiles ?? {}).flat(),
+        ...Object.values(variant.stressFiles ?? {}).flat()
+      ])
+    )
+  ];
+  const supplementalSourceHashes = Object.fromEntries(
+    await Promise.all(
+      supplementalSourcePaths.map(async (filePath) => [
+        import_node_path5.default.relative(paths.researchDir, import_node_path5.default.resolve(filePath)),
+        await sha256File(import_node_path5.default.resolve(filePath))
+      ])
+    )
+  );
+  const sourceHashes = {
+    ...primarySourceHashes,
+    ...supplementalSourceHashes
+  };
+  const result = {
+    schema: CORE_RESEARCH_RESULT_SCHEMA,
+    researchId: spec.researchId,
+    stage: spec.stage,
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    specSha256,
+    lineage: spec.lineage,
+    semantics: {
+      cohortOrder: ["ALL", "LONG", "SHORT"],
+      pnlPerTrade: "cohort PnL / cohort completed positions",
+      drawdown: {
+        ALL: "time-ordered aggregate portfolio realized drawdown",
+        LONG: "time-ordered LONG-only realized drawdown",
+        SHORT: "time-ordered SHORT-only realized drawdown"
+      },
+      regimeCausality: "signal-time payload.additionalIndicators.baseContext only"
+    },
+    variants: analyses,
+    comparisons,
+    multipleTesting: {
+      family: spec.hypothesis.family,
+      hypotheses: Math.max(comparisons.length, familyHypotheses),
+      method: "Holm"
+    },
+    evidence,
+    overfittingDiagnostics: {
+      deflatedSharpe: Object.fromEntries(
+        analyses.map((analysis) => [
+          analysis.variant.id,
+          deflatedSharpeDiagnostic(
+            analysis.monthly.map((window) => window.cohorts.ALL.pnl),
+            Math.max(comparisons.length, familyHypotheses)
+          )
+        ])
+      ),
+      probabilityOfBacktestOverfitting: probabilityOfBacktestOverfitting(
+        analyses.map(
+          (analysis) => analysis.folds.map((window) => window.cohorts.ALL.pnl)
+        )
+      )
+    },
+    artifactHashes: sourceHashes
+  };
+  await writeJsonAtomic(paths.resultPath, result);
+  await writeJsonAtomic(paths.comparisonPath, comparisons);
+  await writeCoreResearchMatches({ filePath: paths.matchesPath, comparisons });
+  await writeCoreResearchTrades({
+    filePath: paths.tradesPath,
+    variants: windowed.map((entry) => ({
+      variantId: entry.variant.id,
+      trades: entry.trades
+    }))
+  });
+  const tradesByVariant = new Map(
+    windowed.map((entry) => [entry.variant.id, entry.trades])
+  );
+  await import_promises4.default.writeFile(
+    paths.reportPath,
+    buildCoreResearchHtml({ spec, result, tradesByVariant }),
+    "utf8"
+  );
+  const artifactHashes = {
+    "spec.json": await sha256File(paths.specPath),
+    "result.json": await sha256File(paths.resultPath),
+    "comparison.json": await sha256File(paths.comparisonPath),
+    "matches.csv": await sha256File(paths.matchesPath),
+    "trades.jsonl": await sha256File(paths.tradesPath),
+    "report.html": await sha256File(paths.reportPath)
+  };
+  const resolvedRunsPath = import_node_path5.default.join(paths.researchDir, "resolved-runs.json");
+  try {
+    artifactHashes["resolved-runs.json"] = await sha256File(resolvedRunsPath);
+  } catch (error) {
+    if (error.code !== "ENOENT") throw error;
+  }
+  try {
+    for (const name of await import_promises4.default.readdir(paths.runLogDir)) {
+      if (!name.endsWith(".log")) continue;
+      artifactHashes[`runs/${name}`] = await sha256File(
+        import_node_path5.default.join(paths.runLogDir, name)
+      );
+    }
+  } catch (error) {
+    if (error.code !== "ENOENT") throw error;
+  }
+  await writeJsonAtomic(paths.manifestPath, {
+    schema: "tradejs-core-research-manifest/v1",
+    researchId: spec.researchId,
+    specSha256,
+    status: "completed",
+    createdAt: spec.createdAt,
+    completedAt: result.generatedAt,
+    selection: Object.fromEntries(
+      comparisons.map((comparison) => [
+        comparison.candidateId,
+        comparison.selection
+      ])
+    ),
+    artifactHashes
+  });
+  await appendCoreResearchLedger({
+    ledgerPath: paths.ledgerPath,
+    researchId: spec.researchId,
+    event: "analysis_completed",
+    specSha256,
+    hypothesisFamily: spec.hypothesis.family,
+    hypothesesInRecord: comparisons.length,
+    artifactHashes
+  });
+  await writeCoreResearchStageIndex(paths.rootDir);
+  return { result, paths, artifactHashes };
+};
+var analyzeCoreResearch = async (spec, options = {}) => {
+  const prepared = options.prepared ?? await prepareCoreResearch(spec);
+  try {
+    return await analyzeCoreResearchPrepared(spec, { ...options, prepared });
+  } catch (error) {
+    if (prepared.manifest.status !== "completed") {
+      try {
+        await appendCoreResearchLedger({
+          ledgerPath: prepared.paths.ledgerPath,
+          researchId: spec.researchId,
+          event: "analysis_failed",
+          specSha256: prepared.specSha256,
+          hypothesisFamily: spec.hypothesis.family,
+          hypothesesInRecord: spec.variants.filter(
+            (variant) => variant.role === "candidate"
+          ).length
+        });
+      } catch {
+      }
+    }
+    throw error;
+  }
+};
+var createCoreResearchSpecTemplate = (params) => {
+  const rootDir = "data/research/core";
+  const projectRoot = process.cwd();
+  const lineage = (() => {
+    try {
+      const gitSha = (0, import_node_child_process.execFileSync)("git", ["rev-parse", "HEAD"], {
+        cwd: projectRoot,
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "ignore"]
+      }).trim();
+      const dirtyDiff = (0, import_node_child_process.execFileSync)(
+        "git",
+        ["diff", "--binary", "--no-ext-diff", "HEAD"],
+        {
+          cwd: projectRoot,
+          encoding: "utf8",
+          stdio: ["ignore", "pipe", "ignore"]
+        }
+      );
+      return {
+        gitSha,
+        ...dirtyDiff ? {
+          dirtyDiffSha256: (0, import_node_crypto5.createHash)("sha256").update(dirtyDiff).digest("hex")
+        } : {}
+      };
+    } catch {
+      return {};
+    }
+  })();
+  return {
+    schema: "tradejs-core-research/v1",
+    researchId: params.researchId,
+    stage: "screen",
+    strategy: params.strategy,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    hypothesis: {
+      family: `${params.strategy}-hypothesis-family`,
+      claim: "Candidate improves the preregistered metric versus control.",
+      mechanism: "Describe the causal mechanism before running the experiment.",
+      target: "ALL"
+    },
+    universe: { symbols: params.symbols, sha256: sha256Json(params.symbols) },
+    window: {
+      start: params.start,
+      end: params.end,
+      terminalDays: [365, 180, 90, 30],
+      folds: 6
+    },
+    execution: {
+      connector: "ByBit",
+      interval: "15",
+      maxLossValue: 10,
+      feeRate: 1e-3,
+      slippageBps: 10,
+      entryDelayBars: 1
+    },
+    variants: [
+      {
+        id: "control",
+        label: "Control",
+        role: "control",
+        configName: `${params.strategy}:control`,
+        resolvedConfig: {},
+        configSha256: sha256Json({}),
+        files: ["data/ai/export/control.jsonl"]
+      },
+      {
+        id: "candidate",
+        label: "Candidate",
+        role: "candidate",
+        configName: `${params.strategy}:candidate`,
+        resolvedConfig: {},
+        configSha256: sha256Json({}),
+        files: ["data/ai/export/candidate.jsonl"]
+      }
+    ],
+    selection: {
+      minimumTrades: 36,
+      minimumCadencePerDay: 0.2,
+      targetRules: [
+        { metric: "pnl", comparison: "gt", relativeToControl: true },
+        { metric: "pnlPerTrade", comparison: "gt", relativeToControl: true },
+        { metric: "profitFactor", comparison: "gte", relativeToControl: true },
+        { metric: "winRatePct", comparison: "gte", relativeToControl: true }
+      ],
+      aggregateRules: [
+        { metric: "pnl", comparison: "gt", relativeToControl: true },
+        {
+          metric: "realizedMaxDrawdown",
+          comparison: "lte",
+          relativeToControl: true
+        }
+      ],
+      nonTargetRules: [],
+      costStressRules: [
+        { metric: "pnl", comparison: "gt", relativeToControl: true },
+        {
+          metric: "realizedMaxDrawdown",
+          comparison: "lte",
+          relativeToControl: true
+        }
+      ],
+      maximumPortfolioDrawdownRegressionPct: 0
+    },
+    robustness: {
+      bootstrapIterations: 2e3,
+      confidenceLevel: 0.95,
+      clusterDays: 7,
+      minimumFoldTrades: 20,
+      costStressBps: [5, 10, 20]
+    },
+    artifacts: {
+      rootDir,
+      ledgerPath: `${rootDir}/trials.jsonl`
+    },
+    lineage,
+    outputPath: params.outputPath
+  };
+};
+var runCommand = async (params) => {
+  if (!params.command.length) throw new Error("Cannot run an empty command");
+  await import_promises4.default.mkdir(import_node_path5.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,
+    env: process.env,
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  const capture = (chunk) => {
+    const text = chunk.toString("utf8");
+    chunks.push(text);
+    process.stdout.write(text);
+    text.split(/\r?\n/).filter(Boolean).forEach((line) => params.onLine?.(line));
+  };
+  child.stdout.on("data", capture);
+  child.stderr.on("data", capture);
+  const exitCode = await new Promise((resolve, reject) => {
+    child.once("error", reject);
+    child.once("close", (code) => resolve(code ?? 1));
+  });
+  const output = chunks.join("");
+  await import_promises4.default.writeFile(params.logPath, output, "utf8");
+  if (exitCode !== 0) {
+    throw new Error(
+      `Command failed with exit ${exitCode}: ${params.command.join(" ")}`
+    );
+  }
+  return output;
+};
+var commandValue = (command, names) => {
+  for (let index = 0; index < command.length; index += 1) {
+    const token = command[index];
+    if (names.includes(token)) return command[index + 1];
+    for (const name of names) {
+      if (token.startsWith(`${name}=`)) return token.slice(name.length + 1);
+    }
+  }
+  return void 0;
+};
+var commandHas = (command, names) => command.some(
+  (token) => names.includes(token) || names.some((name) => token.startsWith(`${name}=`))
+);
+var validateCoreResearchRunCommand = (params) => {
+  const { spec, variant } = params;
+  const command = variant.command ?? [];
+  const failures = [];
+  if (!commandHas(command, ["--ai", "-A"])) failures.push("--ai");
+  if (!commandHas(command, ["--fast"])) failures.push("--fast");
+  if (!commandHas(command, ["--cacheOnly", "-C"])) failures.push("--cacheOnly");
+  if (commandHas(command, ["--continue", "-K", "--runId", "-R"])) {
+    failures.push("fresh-run-only");
+  }
+  if (commandValue(command, ["--config", "-c"]) !== variant.configName) {
+    failures.push(`config=${variant.configName}`);
+  }
+  if (Number(commandValue(command, ["--startTime"])) !== spec.window.start) {
+    failures.push(`startTime=${spec.window.start}`);
+  }
+  if (Number(commandValue(command, ["--endTime"])) !== spec.window.end) {
+    failures.push(`endTime=${spec.window.end}`);
+  }
+  const tickers = (commandValue(command, ["--tickers", "-t"]) ?? "").split(",").map((symbol) => symbol.trim()).filter(Boolean);
+  if (sha256Json(tickers) !== spec.universe.sha256) {
+    failures.push("frozen ordered ticker universe");
+  }
+  if (failures.length) {
+    throw new Error(
+      `Variant ${variant.id} run command failed preflight: ${failures.join(", ")}`
+    );
+  }
+};
+var runCoreResearch = async (params) => {
+  const { spec } = params;
+  const cwd = import_node_path5.default.resolve(params.cwd ?? process.cwd());
+  const prepared = await prepareCoreResearch(spec);
+  const resolvedVariants = [];
+  for (const variant of spec.variants) {
+    if (!variant.command?.length) {
+      resolvedVariants.push(variant);
+      continue;
+    }
+    validateCoreResearchRunCommand({ spec, variant });
+    await appendCoreResearchLedger({
+      ledgerPath: prepared.paths.ledgerPath,
+      researchId: spec.researchId,
+      event: "run_started",
+      specSha256: prepared.specSha256,
+      hypothesisFamily: spec.hypothesis.family,
+      artifactHashes: { variant: sha256Json(variant) }
+    });
+    let runId = "";
+    const backtestLogPath = import_node_path5.default.join(
+      prepared.paths.runLogDir,
+      `${variant.id}-backtest.log`
+    );
+    try {
+      await runCommand({
+        command: variant.command,
+        cwd,
+        logPath: backtestLogPath,
+        onLine: (line) => {
+          const match = line.match(
+            /backtest run id:\s*([0-9]{12}-[a-f0-9]{8})/i
+          );
+          if (match) runId = match[1];
+        }
+      });
+      if (!runId) {
+        throw new Error(`Backtest for ${variant.id} did not report a run id`);
+      }
+      const exportLogPath = import_node_path5.default.join(
+        prepared.paths.runLogDir,
+        `${variant.id}-export.log`
+      );
+      const exportParts = [];
+      const cliPath = import_node_path5.default.resolve(process.argv[1]);
+      await runCommand({
+        command: [
+          process.execPath,
+          cliPath,
+          "ai-export",
+          "--strategy",
+          spec.strategy,
+          "--runId",
+          runId,
+          "--partMonths",
+          "0",
+          "--keepChunks",
+          "true"
+        ],
+        cwd,
+        logPath: exportLogPath,
+        onLine: (line) => {
+          const match = line.match(/^part\d+:\s+(.+)$/);
+          if (match) exportParts.push(import_node_path5.default.resolve(cwd, match[1].trim()));
+        }
+      });
+      if (!exportParts.length) {
+        throw new Error(
+          `AI export for ${variant.id} did not report output files`
+        );
+      }
+      const traceFiles = await (0, import_coreResearch.listCoreResearchTraceFiles)({
+        strategyName: spec.strategy,
+        runId,
+        outDir: import_node_path5.default.resolve(cwd, "data/research/core/trace")
+      });
+      resolvedVariants.push({
+        ...variant,
+        runId,
+        files: exportParts,
+        traceFiles: traceFiles.length ? traceFiles : variant.traceFiles
+      });
+      await appendCoreResearchLedger({
+        ledgerPath: prepared.paths.ledgerPath,
+        researchId: spec.researchId,
+        event: "run_completed",
+        specSha256: prepared.specSha256,
+        hypothesisFamily: spec.hypothesis.family,
+        artifactHashes: {
+          [`runs/${variant.id}-backtest.log`]: await sha256File(backtestLogPath),
+          [`runs/${variant.id}-export.log`]: await sha256File(exportLogPath),
+          ...Object.fromEntries(
+            await Promise.all(
+              exportParts.map(async (filePath) => [
+                import_node_path5.default.basename(filePath),
+                await sha256File(filePath)
+              ])
+            )
+          )
+        }
+      });
+    } catch (error) {
+      await appendCoreResearchLedger({
+        ledgerPath: prepared.paths.ledgerPath,
+        researchId: spec.researchId,
+        event: "run_failed",
+        specSha256: prepared.specSha256,
+        hypothesisFamily: spec.hypothesis.family
+      });
+      throw error;
+    }
+  }
+  await writeJsonAtomic(
+    import_node_path5.default.join(prepared.paths.researchDir, "resolved-runs.json"),
+    {
+      schema: "tradejs-core-research-resolved-runs/v1",
+      researchId: spec.researchId,
+      variants: resolvedVariants
+    }
+  );
+  return analyzeCoreResearch(spec, {
+    prepared,
+    variants: resolvedVariants
+  });
+};
+
+// src/scripts/coreResearch.ts
+var valueAfter = (argv, name) => {
+  const index = argv.indexOf(name);
+  if (index < 0) return void 0;
+  return argv[index + 1];
+};
+var required = (value, name) => {
+  if (!value?.trim()) throw new Error(`${name} is required`);
+  return value.trim();
+};
+var parseTimestamp = (value, name) => {
+  const text = required(value, name);
+  const numeric = /^\d+$/.test(text) ? Number(text) : Date.parse(text);
+  if (!Number.isFinite(numeric)) throw new Error(`${name} is invalid: ${text}`);
+  return numeric;
+};
+var readSymbols = async (argv) => {
+  const symbolsFile = valueAfter(argv, "--symbolsFile");
+  if (symbolsFile) {
+    const parsed = JSON.parse(
+      await import_promises5.default.readFile(import_node_path6.default.resolve(symbolsFile), "utf8")
+    );
+    if (!Array.isArray(parsed) || parsed.some((symbol) => typeof symbol !== "string")) {
+      throw new Error("--symbolsFile must contain a JSON string array");
+    }
+    return parsed;
+  }
+  return required(valueAfter(argv, "--symbols"), "--symbols").split(",").map((symbol) => symbol.trim()).filter(Boolean);
+};
+var printUsage = () => {
+  console.log(`Usage:
+  yarn research:core init --out <spec.json> --researchId <id> --strategy <name> --start <ts> --end <ts> (--symbols <csv> | --symbolsFile <json>)
+  yarn research:core prepare --spec <spec.json>
+  yarn research:core analyze --spec <spec.json>
+  yarn research:core run --spec <spec.json>
+  yarn research:core verify --spec <spec.json>
+  yarn research:core index --root <data/research/core>
+
+The run command executes only variants with an explicit command[] in the preregistered spec. Variants with files[] are analyzed without starting a backtest.`);
+};
+var main = async () => {
+  const argv = process.argv.slice(2);
+  const command = argv[0];
+  if (!command || !["init", "prepare", "analyze", "run", "verify", "index"].includes(command)) {
+    printUsage();
+    if (command) process.exitCode = 1;
+    return;
+  }
+  if (command === "index") {
+    const rootDir = import_node_path6.default.resolve(
+      required(valueAfter(argv, "--root"), "--root")
+    );
+    const index = await writeCoreResearchStageIndex(rootDir);
+    console.log(
+      import_chalk.default.green(
+        `Core research index: ${import_node_path6.default.join(rootDir, "index.json")} (${index.families.length} families)`
+      )
+    );
+    return;
+  }
+  if (command === "init") {
+    const outputPath = import_node_path6.default.resolve(
+      required(valueAfter(argv, "--out"), "--out")
+    );
+    const spec = createCoreResearchSpecTemplate({
+      researchId: required(valueAfter(argv, "--researchId"), "--researchId"),
+      strategy: required(valueAfter(argv, "--strategy"), "--strategy"),
+      symbols: await readSymbols(argv),
+      start: parseTimestamp(valueAfter(argv, "--start"), "--start"),
+      end: parseTimestamp(valueAfter(argv, "--end"), "--end"),
+      outputPath
+    });
+    const { outputPath: _outputPath, ...persisted } = spec;
+    await writeJsonAtomic(outputPath, persisted);
+    console.log(import_chalk.default.green(`Core research spec created: ${outputPath}`));
+    console.log(
+      import_chalk.default.yellow(
+        "Draft only: fill each variants[].resolvedConfig and configSha256 before prepare/analyze/run."
+      )
+    );
+    return;
+  }
+  const specPath = required(valueAfter(argv, "--spec"), "--spec");
+  const loaded = await loadCoreResearchSpec(specPath);
+  if (command === "prepare") {
+    const result = await prepareCoreResearch(loaded.spec);
+    console.log(
+      import_chalk.default.green(
+        `Prepared ${loaded.spec.researchId}: ${result.paths.researchDir}`
+      )
+    );
+    return;
+  }
+  if (command === "analyze") {
+    const analyzed = await analyzeCoreResearch(loaded.spec);
+    console.log(
+      import_chalk.default.green(`Core research report: ${analyzed.paths.reportPath}`)
+    );
+    return;
+  }
+  if (command === "run") {
+    const analyzed = await runCoreResearch({ spec: loaded.spec });
+    console.log(
+      import_chalk.default.green(`Core research report: ${analyzed.paths.reportPath}`)
+    );
+    return;
+  }
+  const verified = await verifyCoreResearchArtifacts(loaded.spec);
+  console.log(import_chalk.default.green(JSON.stringify(verified, null, 2)));
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  main
+});