@tradejs/cli 3.1.0 → 3.1.1

package/dist/scripts/coreResearch.js

@@ -34,7 +34,7 @@ __export(coreResearch_exports, {
 });
 module.exports = __toCommonJS(coreResearch_exports);
 var import_promises5 = __toESM(require("fs/promises"));
-var import_node_path6 = __toESM(require("path"));
+var import_node_path7 = __toESM(require("path"));
 var import_chalk = __toESM(require("chalk"));
 
 // src/lib/coreResearch/io.ts
@@ -641,7 +641,7 @@ var writeCoreResearchStageIndex = async (rootDir) => {
 
 // src/lib/coreResearch/orchestrator.ts
 var import_promises4 = __toESM(require("fs/promises"));
-var import_node_path5 = __toESM(require("path"));
+var import_node_path6 = __toESM(require("path"));
 var import_node_child_process = require("child_process");
 var import_node_crypto5 = require("crypto");
 var import_coreResearch = require("@tradejs/infra/coreResearch");
@@ -2107,6 +2107,26 @@ var summarizeCoreResearchTrace = async (filePaths = []) => {
   };
 };
 
+// src/lib/researchRoots.ts
+var import_node_path5 = __toESM(require("path"));
+var SOURCE_REPOSITORY_ROOT_ENV = "TRADEJS_SOURCE_REPOSITORY_ROOT";
+var firstNonEmpty = (...values) => values.map((value) => String(value || "").trim()).find(Boolean);
+var resolveResearchRoots = (options = {}) => {
+  const cwd = import_node_path5.default.resolve(options.cwd || process.cwd());
+  const env = options.env || process.env;
+  const projectRoot = import_node_path5.default.resolve(
+    firstNonEmpty(options.projectRoot, env.PROJECT_CWD, cwd) || cwd
+  );
+  const sourceRepositoryRoot = import_node_path5.default.resolve(
+    firstNonEmpty(
+      options.sourceRepositoryRoot,
+      env[SOURCE_REPOSITORY_ROOT_ENV],
+      cwd
+    ) || cwd
+  );
+  return { projectRoot, sourceRepositoryRoot };
+};
+
 // src/lib/coreResearch/orchestrator.ts
 var summarizeSupplementalFiles = async (params) => {
   const loaded = await readCoreResearchVariant({
@@ -2299,7 +2319,7 @@ var analyzeCoreResearchPrepared = async (spec, options = {}) => {
   const primarySourceHashes = Object.fromEntries(
     analyses.flatMap(
       (analysis) => analysis.files.map((file) => [
-        import_node_path5.default.relative(paths.researchDir, file.path),
+        import_node_path6.default.relative(paths.researchDir, file.path),
         file.sha256
       ])
     )
@@ -2318,8 +2338,8 @@ var analyzeCoreResearchPrepared = async (spec, options = {}) => {
   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))
+        import_node_path6.default.relative(paths.researchDir, import_node_path6.default.resolve(filePath)),
+        await sha256File(import_node_path6.default.resolve(filePath))
       ])
     )
   );
@@ -2396,7 +2416,7 @@ var analyzeCoreResearchPrepared = async (spec, options = {}) => {
     "trades.jsonl": await sha256File(paths.tradesPath),
     "report.html": await sha256File(paths.reportPath)
   };
-  const resolvedRunsPath = import_node_path5.default.join(paths.researchDir, "resolved-runs.json");
+  const resolvedRunsPath = import_node_path6.default.join(paths.researchDir, "resolved-runs.json");
   try {
     artifactHashes["resolved-runs.json"] = await sha256File(resolvedRunsPath);
   } catch (error) {
@@ -2406,7 +2426,7 @@ var analyzeCoreResearchPrepared = async (spec, options = {}) => {
     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)
+        import_node_path6.default.join(paths.runLogDir, name)
       );
     }
   } catch (error) {
@@ -2463,12 +2483,14 @@ var analyzeCoreResearch = async (spec, options = {}) => {
   }
 };
 var createCoreResearchSpecTemplate = (params) => {
-  const rootDir = "data/research/core";
-  const projectRoot = process.cwd();
+  const rootDir = import_node_path6.default.relative(
+    import_node_path6.default.resolve(params.projectRoot),
+    import_node_path6.default.join(import_node_path6.default.resolve(params.projectRoot), "data", "research", "core")
+  ).replace(/\\/g, "/");
   const lineage = (() => {
     try {
       const gitSha = (0, import_node_child_process.execFileSync)("git", ["rev-parse", "HEAD"], {
-        cwd: projectRoot,
+        cwd: params.sourceRepositoryRoot,
         encoding: "utf8",
         stdio: ["ignore", "pipe", "ignore"]
       }).trim();
@@ -2476,13 +2498,23 @@ var createCoreResearchSpecTemplate = (params) => {
         "git",
         ["diff", "--binary", "--no-ext-diff", "HEAD"],
         {
-          cwd: projectRoot,
+          cwd: params.sourceRepositoryRoot,
           encoding: "utf8",
           stdio: ["ignore", "pipe", "ignore"]
         }
       );
+      const sourceRepository = (0, import_node_child_process.execFileSync)(
+        "git",
+        ["remote", "get-url", "origin"],
+        {
+          cwd: params.sourceRepositoryRoot,
+          encoding: "utf8",
+          stdio: ["ignore", "pipe", "ignore"]
+        }
+      ).trim();
       return {
         gitSha,
+        ...sourceRepository ? { sourceRepository } : {},
         ...dirtyDiff ? {
           dirtyDiffSha256: (0, import_node_crypto5.createHash)("sha256").update(dirtyDiff).digest("hex")
         } : {}
@@ -2583,11 +2615,11 @@ var createCoreResearchSpecTemplate = (params) => {
 };
 var runCommand = async (params) => {
   if (!params.command.length) throw new Error("Cannot run an empty command");
-  await import_promises4.default.mkdir(import_node_path5.default.dirname(params.logPath), { recursive: true });
+  await import_promises4.default.mkdir(import_node_path6.default.dirname(params.logPath), { recursive: true });
   const chunks = [];
   const child = (0, import_node_child_process.spawn)(params.command[0], params.command.slice(1), {
     cwd: params.cwd,
-    env: process.env,
+    env: { ...process.env, ...params.env },
     stdio: ["ignore", "pipe", "pipe"]
   });
   const capture = (chunk) => {
@@ -2655,7 +2687,7 @@ var validateCoreResearchRunCommand = (params) => {
 };
 var runCoreResearch = async (params) => {
   const { spec } = params;
-  const cwd = import_node_path5.default.resolve(params.cwd ?? process.cwd());
+  const cwd = import_node_path6.default.resolve(params.cwd ?? process.cwd());
   const prepared = await prepareCoreResearch(spec);
   const resolvedVariants = [];
   for (const variant of spec.variants) {
@@ -2673,7 +2705,7 @@ var runCoreResearch = async (params) => {
       artifactHashes: { variant: sha256Json(variant) }
     });
     let runId = "";
-    const backtestLogPath = import_node_path5.default.join(
+    const backtestLogPath = import_node_path6.default.join(
       prepared.paths.runLogDir,
       `${variant.id}-backtest.log`
     );
@@ -2682,6 +2714,14 @@ var runCoreResearch = async (params) => {
         command: variant.command,
         cwd,
         logPath: backtestLogPath,
+        env: {
+          PROJECT_CWD: cwd,
+          ...params.sourceRepositoryRoot ? {
+            [SOURCE_REPOSITORY_ROOT_ENV]: import_node_path6.default.resolve(
+              params.sourceRepositoryRoot
+            )
+          } : {}
+        },
         onLine: (line) => {
           const match = line.match(
             /backtest run id:\s*([0-9]{12}-[a-f0-9]{8})/i
@@ -2692,12 +2732,12 @@ var runCoreResearch = async (params) => {
       if (!runId) {
         throw new Error(`Backtest for ${variant.id} did not report a run id`);
       }
-      const exportLogPath = import_node_path5.default.join(
+      const exportLogPath = import_node_path6.default.join(
         prepared.paths.runLogDir,
         `${variant.id}-export.log`
       );
       const exportParts = [];
-      const cliPath = import_node_path5.default.resolve(process.argv[1]);
+      const cliPath = import_node_path6.default.resolve(process.argv[1]);
       await runCommand({
         command: [
           process.execPath,
@@ -2714,9 +2754,17 @@ var runCoreResearch = async (params) => {
         ],
         cwd,
         logPath: exportLogPath,
+        env: {
+          PROJECT_CWD: cwd,
+          ...params.sourceRepositoryRoot ? {
+            [SOURCE_REPOSITORY_ROOT_ENV]: import_node_path6.default.resolve(
+              params.sourceRepositoryRoot
+            )
+          } : {}
+        },
         onLine: (line) => {
           const match = line.match(/^part\d+:\s+(.+)$/);
-          if (match) exportParts.push(import_node_path5.default.resolve(cwd, match[1].trim()));
+          if (match) exportParts.push(import_node_path6.default.resolve(cwd, match[1].trim()));
         }
       });
       if (!exportParts.length) {
@@ -2727,7 +2775,7 @@ var runCoreResearch = async (params) => {
       const traceFiles = await (0, import_coreResearch.listCoreResearchTraceFiles)({
         strategyName: spec.strategy,
         runId,
-        outDir: import_node_path5.default.resolve(cwd, "data/research/core/trace")
+        outDir: import_node_path6.default.resolve(cwd, "data/research/core/trace")
       });
       resolvedVariants.push({
         ...variant,
@@ -2747,7 +2795,7 @@ var runCoreResearch = async (params) => {
           ...Object.fromEntries(
             await Promise.all(
               exportParts.map(async (filePath) => [
-                import_node_path5.default.basename(filePath),
+                import_node_path6.default.basename(filePath),
                 await sha256File(filePath)
               ])
             )
@@ -2766,7 +2814,7 @@ var runCoreResearch = async (params) => {
     }
   }
   await writeJsonAtomic(
-    import_node_path5.default.join(prepared.paths.researchDir, "resolved-runs.json"),
+    import_node_path6.default.join(prepared.paths.researchDir, "resolved-runs.json"),
     {
       schema: "tradejs-core-research-resolved-runs/v1",
       researchId: spec.researchId,
@@ -2795,11 +2843,11 @@ var parseTimestamp = (value, name) => {
   if (!Number.isFinite(numeric)) throw new Error(`${name} is invalid: ${text}`);
   return numeric;
 };
-var readSymbols = async (argv) => {
+var readSymbols = async (argv, projectRoot) => {
   const symbolsFile = valueAfter(argv, "--symbolsFile");
   if (symbolsFile) {
     const parsed = JSON.parse(
-      await import_promises5.default.readFile(import_node_path6.default.resolve(symbolsFile), "utf8")
+      await import_promises5.default.readFile(import_node_path7.default.resolve(projectRoot, symbolsFile), "utf8")
     );
     if (!Array.isArray(parsed) || parsed.some((symbol) => typeof symbol !== "string")) {
       throw new Error("--symbolsFile must contain a JSON string array");
@@ -2820,6 +2868,8 @@ var printUsage = () => {
 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 roots = resolveResearchRoots();
+  process.chdir(roots.projectRoot);
   const argv = process.argv.slice(2);
   const command = argv[0];
   if (!command || !["init", "prepare", "analyze", "run", "verify", "index"].includes(command)) {
@@ -2828,28 +2878,32 @@ var main = async () => {
     return;
   }
   if (command === "index") {
-    const rootDir = import_node_path6.default.resolve(
+    const rootDir = import_node_path7.default.resolve(
+      roots.projectRoot,
       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)`
+        `Core research index: ${import_node_path7.default.join(rootDir, "index.json")} (${index.families.length} families)`
       )
     );
     return;
   }
   if (command === "init") {
-    const outputPath = import_node_path6.default.resolve(
+    const outputPath = import_node_path7.default.resolve(
+      roots.projectRoot,
       required(valueAfter(argv, "--out"), "--out")
     );
     const spec = createCoreResearchSpecTemplate({
       researchId: required(valueAfter(argv, "--researchId"), "--researchId"),
       strategy: required(valueAfter(argv, "--strategy"), "--strategy"),
-      symbols: await readSymbols(argv),
+      symbols: await readSymbols(argv, roots.projectRoot),
       start: parseTimestamp(valueAfter(argv, "--start"), "--start"),
       end: parseTimestamp(valueAfter(argv, "--end"), "--end"),
-      outputPath
+      outputPath,
+      projectRoot: roots.projectRoot,
+      sourceRepositoryRoot: roots.sourceRepositoryRoot
     });
     const { outputPath: _outputPath, ...persisted } = spec;
     await writeJsonAtomic(outputPath, persisted);
@@ -2861,7 +2915,10 @@ var main = async () => {
     );
     return;
   }
-  const specPath = required(valueAfter(argv, "--spec"), "--spec");
+  const specPath = import_node_path7.default.resolve(
+    roots.projectRoot,
+    required(valueAfter(argv, "--spec"), "--spec")
+  );
   const loaded = await loadCoreResearchSpec(specPath);
   if (command === "prepare") {
     const result = await prepareCoreResearch(loaded.spec);
@@ -2880,7 +2937,11 @@ var main = async () => {
     return;
   }
   if (command === "run") {
-    const analyzed = await runCoreResearch({ spec: loaded.spec });
+    const analyzed = await runCoreResearch({
+      spec: loaded.spec,
+      cwd: roots.projectRoot,
+      sourceRepositoryRoot: roots.sourceRepositoryRoot
+    });
     console.log(
       import_chalk.default.green(`Core research report: ${analyzed.paths.reportPath}`)
     );

package/dist/scripts/replay.js

@@ -4347,7 +4347,7 @@ var buildRuntimeModeStrategyConfig = ({
   ...strategyConfig,
   ENV: env,
   MAKE_ORDERS: makeOrders,
-  INTERVAL: interval,
+  INTERVAL: strategyConfig.INTERVAL ?? interval,
   ...typeof recordRuntimeTrades === "boolean" ? { RECORD_RUNTIME_TRADES: recordRuntimeTrades } : {},
   ...aiReplayAnalyses?.length ? { AI_REPLAY_ANALYSES: aiReplayAnalyses } : {}
 });
@@ -5135,14 +5135,29 @@ var resolveRuntimeGateFingerprint = async ({
   gateFingerprintCache.set(cacheKey, result);
   return result;
 };
-var buildRuntimeLineage = async ({
+async function buildRuntimeLineage({
   projectRoot,
   strategyName,
   compositionId,
+  releaseVersion,
+  strategyPackageVersion,
+  runtimePackageVersion,
   config,
   runContext,
   env = process.env
-}) => {
+}) {
+  if (releaseVersion != null) {
+    if (!Number.isSafeInteger(releaseVersion) || releaseVersion <= 0) {
+      throw new Error(`Invalid runtime releaseVersion: ${releaseVersion}`);
+    }
+    return {
+      schemaVersion: 2,
+      releaseVersion,
+      strategyPackageVersion,
+      runtimePackageVersion,
+      maxLossValue: resolveRuntimeMaxLossValue(config)
+    };
+  }
   const git = resolveGitLineage(projectRoot);
   const hyperliquidPerpUniverseFingerprint = typeof import_strategies3.getHyperliquidPerpUniverseSnapshot === "function" ? (0, import_strategies3.getHyperliquidPerpUniverseSnapshot)().fingerprint : await resolveSnapshotFingerprint(
     projectRoot,
@@ -5177,8 +5192,8 @@ var buildRuntimeLineage = async ({
     contextFingerprint: fingerprintRuntimeValue(context),
     maxLossValue: resolveRuntimeMaxLossValue(config)
   };
-};
-var runtimeLineageKey = (lineage) => [
+}
+var runtimeLineageKey = (lineage) => lineage.schemaVersion === 2 ? ["v2", lineage.releaseVersion].join(":") : [
   lineage.schemaVersion,
   lineage.compositionId ?? "unbound-composition",
   lineage.gitSha ?? "unknown",
@@ -5430,6 +5445,7 @@ var runHistoricalSignalsReplay = async ({
               userName: replayUserName,
               connectorName,
               runtimeConfigId: "config",
+              runtimeLineage,
               config: buildReplayStrategyConfig({
                 strategyConfig,
                 interval
@@ -7210,6 +7226,7 @@ var buildRuntimeEvidenceLineageScopes = ({
     strategy,
     symbol,
     runtimeConfigId,
+    runtimeReleaseVersion,
     timestamp,
     lineage
   }) => {
@@ -7222,6 +7239,7 @@ var buildRuntimeEvidenceLineageScopes = ({
       strategy,
       symbol,
       ...runtimeConfigId ? { runtimeConfigId } : {},
+      ...runtimeReleaseVersion ? { runtimeReleaseVersion } : {},
       lineage,
       firstTimestamp: existing ? Math.min(existing.firstTimestamp, timestamp) : timestamp,
       lastTimestamp: existing ? Math.max(existing.lastTimestamp, timestamp) : timestamp
@@ -7232,6 +7250,7 @@ var buildRuntimeEvidenceLineageScopes = ({
       strategy: signal.strategy,
       symbol: signal.symbol,
       runtimeConfigId: signal.runtimeConfigId,
+      runtimeReleaseVersion: signal.runtimeReleaseVersion,
       timestamp: signal.timestamp,
       lineage: signal.runtimeLineage
     });
@@ -7241,6 +7260,7 @@ var buildRuntimeEvidenceLineageScopes = ({
       strategy: evaluation.strategy,
       symbol: evaluation.symbol,
       runtimeConfigId: evaluation.runtimeConfigId,
+      runtimeReleaseVersion: evaluation.runtimeReleaseVersion,
       timestamp: evaluation.timestamp,
       lineage: evaluation.runtimeLineage
     });
@@ -8551,13 +8571,26 @@ var renderLineageRows = (runtimeComparison) => {
       contexts: /* @__PURE__ */ new Set()
     };
     existing.scopes += 1;
-    existing.gitShas.add(record.lineage.gitSha ?? "unknown");
-    existing.dirty.add(
-      record.lineage.gitDirty == null ? "unknown" : String(record.lineage.gitDirty)
-    );
-    existing.gates.add(record.lineage.gateFingerprint);
-    existing.configs.add(record.lineage.configFingerprint);
-    existing.contexts.add(record.lineage.contextFingerprint);
+    if (record.lineage.schemaVersion === 2) {
+      existing.gitShas.add("release-versioned");
+      existing.dirty.add("n/a");
+      existing.gates.add("release-versioned");
+      existing.configs.add(`v${record.lineage.releaseVersion}`);
+      existing.contexts.add(
+        [
+          record.lineage.strategyPackageVersion ?? "strategy:unknown",
+          record.lineage.runtimePackageVersion ?? "runtime:unknown"
+        ].join("/")
+      );
+    } else {
+      existing.gitShas.add(record.lineage.gitSha ?? "unknown");
+      existing.dirty.add(
+        record.lineage.gitDirty == null ? "unknown" : String(record.lineage.gitDirty)
+      );
+      existing.gates.add(record.lineage.gateFingerprint);
+      existing.configs.add(record.lineage.configFingerprint);
+      existing.contexts.add(record.lineage.contextFingerprint);
+    }
     grouped.set(record.strategy, existing);
   }
   const formatSet = (values) => {

package/dist/scripts/replayRunner.js

@@ -4350,7 +4350,7 @@ var buildRuntimeModeStrategyConfig = ({
   ...strategyConfig,
   ENV: env,
   MAKE_ORDERS: makeOrders,
-  INTERVAL: interval,
+  INTERVAL: strategyConfig.INTERVAL ?? interval,
   ...typeof recordRuntimeTrades === "boolean" ? { RECORD_RUNTIME_TRADES: recordRuntimeTrades } : {},
   ...aiReplayAnalyses?.length ? { AI_REPLAY_ANALYSES: aiReplayAnalyses } : {}
 });
@@ -5138,14 +5138,29 @@ var resolveRuntimeGateFingerprint = async ({
   gateFingerprintCache.set(cacheKey, result);
   return result;
 };
-var buildRuntimeLineage = async ({
+async function buildRuntimeLineage({
   projectRoot,
   strategyName,
   compositionId,
+  releaseVersion,
+  strategyPackageVersion,
+  runtimePackageVersion,
   config,
   runContext,
   env = process.env
-}) => {
+}) {
+  if (releaseVersion != null) {
+    if (!Number.isSafeInteger(releaseVersion) || releaseVersion <= 0) {
+      throw new Error(`Invalid runtime releaseVersion: ${releaseVersion}`);
+    }
+    return {
+      schemaVersion: 2,
+      releaseVersion,
+      strategyPackageVersion,
+      runtimePackageVersion,
+      maxLossValue: resolveRuntimeMaxLossValue(config)
+    };
+  }
   const git = resolveGitLineage(projectRoot);
   const hyperliquidPerpUniverseFingerprint = typeof import_strategies3.getHyperliquidPerpUniverseSnapshot === "function" ? (0, import_strategies3.getHyperliquidPerpUniverseSnapshot)().fingerprint : await resolveSnapshotFingerprint(
     projectRoot,
@@ -5180,8 +5195,8 @@ var buildRuntimeLineage = async ({
     contextFingerprint: fingerprintRuntimeValue(context),
     maxLossValue: resolveRuntimeMaxLossValue(config)
   };
-};
-var runtimeLineageKey = (lineage) => [
+}
+var runtimeLineageKey = (lineage) => lineage.schemaVersion === 2 ? ["v2", lineage.releaseVersion].join(":") : [
   lineage.schemaVersion,
   lineage.compositionId ?? "unbound-composition",
   lineage.gitSha ?? "unknown",
@@ -5433,6 +5448,7 @@ var runHistoricalSignalsReplay = async ({
               userName: replayUserName,
               connectorName,
               runtimeConfigId: "config",
+              runtimeLineage,
               config: buildReplayStrategyConfig({
                 strategyConfig,
                 interval
@@ -7213,6 +7229,7 @@ var buildRuntimeEvidenceLineageScopes = ({
     strategy,
     symbol,
     runtimeConfigId,
+    runtimeReleaseVersion,
     timestamp,
     lineage
   }) => {
@@ -7225,6 +7242,7 @@ var buildRuntimeEvidenceLineageScopes = ({
       strategy,
       symbol,
       ...runtimeConfigId ? { runtimeConfigId } : {},
+      ...runtimeReleaseVersion ? { runtimeReleaseVersion } : {},
       lineage,
       firstTimestamp: existing ? Math.min(existing.firstTimestamp, timestamp) : timestamp,
       lastTimestamp: existing ? Math.max(existing.lastTimestamp, timestamp) : timestamp
@@ -7235,6 +7253,7 @@ var buildRuntimeEvidenceLineageScopes = ({
       strategy: signal.strategy,
       symbol: signal.symbol,
       runtimeConfigId: signal.runtimeConfigId,
+      runtimeReleaseVersion: signal.runtimeReleaseVersion,
       timestamp: signal.timestamp,
       lineage: signal.runtimeLineage
     });
@@ -7244,6 +7263,7 @@ var buildRuntimeEvidenceLineageScopes = ({
       strategy: evaluation.strategy,
       symbol: evaluation.symbol,
       runtimeConfigId: evaluation.runtimeConfigId,
+      runtimeReleaseVersion: evaluation.runtimeReleaseVersion,
       timestamp: evaluation.timestamp,
       lineage: evaluation.runtimeLineage
     });
@@ -8554,13 +8574,26 @@ var renderLineageRows = (runtimeComparison) => {
       contexts: /* @__PURE__ */ new Set()
     };
     existing.scopes += 1;
-    existing.gitShas.add(record.lineage.gitSha ?? "unknown");
-    existing.dirty.add(
-      record.lineage.gitDirty == null ? "unknown" : String(record.lineage.gitDirty)
-    );
-    existing.gates.add(record.lineage.gateFingerprint);
-    existing.configs.add(record.lineage.configFingerprint);
-    existing.contexts.add(record.lineage.contextFingerprint);
+    if (record.lineage.schemaVersion === 2) {
+      existing.gitShas.add("release-versioned");
+      existing.dirty.add("n/a");
+      existing.gates.add("release-versioned");
+      existing.configs.add(`v${record.lineage.releaseVersion}`);
+      existing.contexts.add(
+        [
+          record.lineage.strategyPackageVersion ?? "strategy:unknown",
+          record.lineage.runtimePackageVersion ?? "runtime:unknown"
+        ].join("/")
+      );
+    } else {
+      existing.gitShas.add(record.lineage.gitSha ?? "unknown");
+      existing.dirty.add(
+        record.lineage.gitDirty == null ? "unknown" : String(record.lineage.gitDirty)
+      );
+      existing.gates.add(record.lineage.gateFingerprint);
+      existing.configs.add(record.lineage.configFingerprint);
+      existing.contexts.add(record.lineage.contextFingerprint);
+    }
     grouped.set(record.strategy, existing);
   }
   const formatSet = (values) => {

package/dist/scripts/researchAuto.js

@@ -57,7 +57,7 @@ var import_chalk2 = __toESM(require("chalk"));
 var import_node_child_process = require("child_process");
 var import_promises = __toESM(require("fs/promises"));
 var import_node_os = __toESM(require("os"));
-var import_node_path = __toESM(require("path"));
+var import_node_path2 = __toESM(require("path"));
 var import_constants = require("@tradejs/core/constants");
 var import_ai = require("@tradejs/infra/ai");
 var import_logger = require("@tradejs/infra/logger");
@@ -84,6 +84,26 @@ var BACKTEST_CLI_RUNTIME_CONFIG_KEYS = /* @__PURE__ */ new Set([
   "BACKTEST_ENTRY_DELAY_BARS"
 ]);
 
+// src/lib/researchRoots.ts
+var import_node_path = __toESM(require("path"));
+var SOURCE_REPOSITORY_ROOT_ENV = "TRADEJS_SOURCE_REPOSITORY_ROOT";
+var firstNonEmpty = (...values) => values.map((value) => String(value || "").trim()).find(Boolean);
+var resolveResearchRoots = (options = {}) => {
+  const cwd = import_node_path.default.resolve(options.cwd || process.cwd());
+  const env = options.env || process.env;
+  const projectRoot2 = import_node_path.default.resolve(
+    firstNonEmpty(options.projectRoot, env.PROJECT_CWD, cwd) || cwd
+  );
+  const sourceRepositoryRoot2 = import_node_path.default.resolve(
+    firstNonEmpty(
+      options.sourceRepositoryRoot,
+      env[SOURCE_REPOSITORY_ROOT_ENV],
+      cwd
+    ) || cwd
+  );
+  return { projectRoot: projectRoot2, sourceRepositoryRoot: sourceRepositoryRoot2 };
+};
+
 // src/lib/telegramReports.ts
 var import_cli = require("@tradejs/node/cli");
 var TELEGRAM_REPORT_CHUNK_LIMIT = 3900;
@@ -175,11 +195,11 @@ import_args.default.option(["O", "outDir"], "AI export output directory", "data/
 import_args.default.option(["A", "skipAgent"], "Skip direct research agent invocation", false);
 import_args.default.option(["j", "json"], "Print structured JSON summary", false);
 var flags = import_args.default.parse(process.argv);
-var projectRoot = String(process.env.PROJECT_CWD || process.cwd()).trim() || process.cwd();
+var { projectRoot, sourceRepositoryRoot } = resolveResearchRoots();
 var dotenvPath = String(
-  process.env.DOTENV_CONFIG_PATH || import_node_path.default.join(projectRoot, ".env")
-).trim() || import_node_path.default.join(projectRoot, ".env");
-var getResearchAutoLockPath = (userName) => import_node_path.default.join(
+  process.env.DOTENV_CONFIG_PATH || import_node_path2.default.join(projectRoot, ".env")
+).trim() || import_node_path2.default.join(projectRoot, ".env");
+var getResearchAutoLockPath = (userName) => import_node_path2.default.join(
   projectRoot,
   "data",
   "cache",
@@ -223,7 +243,7 @@ var acquireResearchAutoLock = async ({
     startedAt,
     argv: [...process.argv]
   };
-  await import_promises.default.mkdir(import_node_path.default.dirname(lockPath), { recursive: true });
+  await import_promises.default.mkdir(import_node_path2.default.dirname(lockPath), { recursive: true });
   const writeLock = async () => {
     await import_promises.default.writeFile(lockPath, JSON.stringify(nextLock, null, 2), {
       flag: "wx"
@@ -360,7 +380,7 @@ var listMergedFiles = async (outDir, strategyName) => {
   try {
     const entries = await import_promises.default.readdir(outDir);
     const prefix = `ai-dataset-${(0, import_ai.toFileToken)(strategyName)}-merged-`;
-    return entries.filter((name) => name.startsWith(prefix) && name.endsWith(".jsonl")).sort().map((name) => import_node_path.default.join(outDir, name));
+    return entries.filter((name) => name.startsWith(prefix) && name.endsWith(".jsonl")).sort().map((name) => import_node_path2.default.join(outDir, name));
   } catch {
     return [];
   }
@@ -480,6 +500,7 @@ var runCliCommand = async (params) => {
   const env = {
     ...process.env,
     PROJECT_CWD: projectRoot,
+    [SOURCE_REPOSITORY_ROOT_ENV]: sourceRepositoryRoot,
     DOTENV_CONFIG_PATH: dotenvPath,
     ...params.nodeHeapMb ? {
       NODE_OPTIONS: buildNodeOptions({
@@ -489,8 +510,8 @@ var runCliCommand = async (params) => {
   };
   return new Promise((resolve, reject) => {
     const child = (0, import_node_child_process.spawn)(
-      "bash",
-      ["./bin/run-cli-runtime.sh", params.command, ...params.args],
+      process.execPath,
+      [import_node_path2.default.resolve(process.argv[1]), params.command, ...params.args],
       {
         cwd: projectRoot,
         env,
@@ -672,8 +693,8 @@ var main = async () => {
   const jsonOutput = Boolean(flags.json);
   const skipAgent = Boolean(flags.skipAgent);
   const outDirArg = String(flags.outDir || "data/ai/export").trim() || "data/ai/export";
-  const outDir = import_node_path.default.resolve(projectRoot, outDirArg);
-  const cleanDirArg = import_node_path.default.relative(import_node_path.default.join(projectRoot, "data"), outDir).replace(/\\/g, "/");
+  const outDir = import_node_path2.default.resolve(projectRoot, outDirArg);
+  const cleanDirArg = import_node_path2.default.relative(import_node_path2.default.join(projectRoot, "data"), outDir).replace(/\\/g, "/");
   const target = await resolveTarget();
   const runId = `${Date.now()}-${(0, import_ai.toFileToken)(target.strategy)}`;
   const run = {