@tradejs/cli 3.0.1 → 3.1.1

package/dist/scripts/aiTrain.js

@@ -1001,28 +1001,37 @@ var import_types = require("@tradejs/types");
 
 // src/lib/strategyGateFingerprint.ts
 var import_node_crypto = require("crypto");
+var import_node_module = require("module");
 var import_promises = __toESM(require("fs/promises"));
 var import_node_path = __toESM(require("path"));
-var gateFingerprintRelativePaths = (strategyName) => [
-  `packages/strategies/src/${strategyName}/adapters/ai.ts`,
-  `packages/strategies/src/${strategyName}/guardrails.ts`,
-  `packages/strategies/src/${strategyName}/pockets.ts`,
-  `packages/strategies/src/${strategyName}/config.ts`,
-  "packages/strategies/src/shared/localAiGate.ts",
-  "packages/node/src/ai.ts",
-  "packages/core/src/utils/strategyHelpers/signalBuilders.ts"
+var toPackageToken = (strategyName) => strategyName.replace(/([A-Z]+)([A-Z][a-z])/g, "$1-$2").replace(/([a-z\d])([A-Z])/g, "$1-$2").toLowerCase();
+var getStrategyPackageName = (strategyName) => strategyName === "TrendLine" || strategyName === "ReverseTrendLine" ? "@tradejs/strategy-trend-line" : `@tradejs/strategy-${toPackageToken(strategyName)}`;
+var gateFingerprintSpecifiers = (strategyName) => [
+  getStrategyPackageName(strategyName),
+  "@tradejs/strategy-kit/ai-gate",
+  "@tradejs/node/ai",
+  "@tradejs/core/strategies"
 ];
 var resolveStrategyGateFingerprint = async ({
   projectRoot,
   strategyName,
   gitSha
 }) => {
-  const candidates = await Promise.all(
-    gateFingerprintRelativePaths(strategyName).map(async (relativePath) => {
-      const content = await import_promises.default.readFile(import_node_path.default.join(projectRoot, relativePath)).catch(() => null);
-      return content == null ? null : { relativePath, content };
+  const projectManifestPath = import_node_path.default.join(projectRoot, "package.json");
+  const projectExists = await import_promises.default.access(projectManifestPath).then(() => true).catch(() => false);
+  const requireFromProject = projectExists ? (0, import_node_module.createRequire)(projectManifestPath) : null;
+  const candidates = requireFromProject ? await Promise.all(
+    gateFingerprintSpecifiers(strategyName).map(async (specifier) => {
+      let resolvedPath;
+      try {
+        resolvedPath = requireFromProject.resolve(specifier);
+      } catch {
+        return null;
+      }
+      const content = await import_promises.default.readFile(resolvedPath).catch(() => null);
+      return content == null ? null : { specifier, content };
     })
-  );
+  ) : [];
   const sourceEntries = candidates.filter(
     (entry) => entry != null
   );
@@ -1030,7 +1039,7 @@ var resolveStrategyGateFingerprint = async ({
   hash.update(strategyName);
   if (sourceEntries.length) {
     for (const entry of sourceEntries) {
-      hash.update(entry.relativePath);
+      hash.update(entry.specifier);
       hash.update(entry.content);
     }
   } else {
@@ -1038,7 +1047,7 @@ var resolveStrategyGateFingerprint = async ({
   }
   return {
     gateFingerprint: hash.digest("hex").slice(0, 16),
-    gateFingerprintFiles: sourceEntries.map((entry) => entry.relativePath)
+    gateFingerprintFiles: sourceEntries.map((entry) => entry.specifier)
   };
 };
 

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 } : {}
 });
@@ -4910,28 +4910,37 @@ var import_strategyReleaseEvidence = require("@tradejs/infra/strategyReleaseEvid
 
 // src/lib/strategyGateFingerprint.ts
 var import_node_crypto = require("crypto");
+var import_node_module = require("module");
 var import_promises = __toESM(require("fs/promises"));
 var import_node_path = __toESM(require("path"));
-var gateFingerprintRelativePaths = (strategyName) => [
-  `packages/strategies/src/${strategyName}/adapters/ai.ts`,
-  `packages/strategies/src/${strategyName}/guardrails.ts`,
-  `packages/strategies/src/${strategyName}/pockets.ts`,
-  `packages/strategies/src/${strategyName}/config.ts`,
-  "packages/strategies/src/shared/localAiGate.ts",
-  "packages/node/src/ai.ts",
-  "packages/core/src/utils/strategyHelpers/signalBuilders.ts"
+var toPackageToken = (strategyName) => strategyName.replace(/([A-Z]+)([A-Z][a-z])/g, "$1-$2").replace(/([a-z\d])([A-Z])/g, "$1-$2").toLowerCase();
+var getStrategyPackageName = (strategyName) => strategyName === "TrendLine" || strategyName === "ReverseTrendLine" ? "@tradejs/strategy-trend-line" : `@tradejs/strategy-${toPackageToken(strategyName)}`;
+var gateFingerprintSpecifiers = (strategyName) => [
+  getStrategyPackageName(strategyName),
+  "@tradejs/strategy-kit/ai-gate",
+  "@tradejs/node/ai",
+  "@tradejs/core/strategies"
 ];
 var resolveStrategyGateFingerprint = async ({
   projectRoot,
   strategyName,
   gitSha
 }) => {
-  const candidates = await Promise.all(
-    gateFingerprintRelativePaths(strategyName).map(async (relativePath) => {
-      const content = await import_promises.default.readFile(import_node_path.default.join(projectRoot, relativePath)).catch(() => null);
-      return content == null ? null : { relativePath, content };
+  const projectManifestPath = import_node_path.default.join(projectRoot, "package.json");
+  const projectExists = await import_promises.default.access(projectManifestPath).then(() => true).catch(() => false);
+  const requireFromProject = projectExists ? (0, import_node_module.createRequire)(projectManifestPath) : null;
+  const candidates = requireFromProject ? await Promise.all(
+    gateFingerprintSpecifiers(strategyName).map(async (specifier) => {
+      let resolvedPath;
+      try {
+        resolvedPath = requireFromProject.resolve(specifier);
+      } catch {
+        return null;
+      }
+      const content = await import_promises.default.readFile(resolvedPath).catch(() => null);
+      return content == null ? null : { specifier, content };
     })
-  );
+  ) : [];
   const sourceEntries = candidates.filter(
     (entry) => entry != null
   );
@@ -4939,7 +4948,7 @@ var resolveStrategyGateFingerprint = async ({
   hash.update(strategyName);
   if (sourceEntries.length) {
     for (const entry of sourceEntries) {
-      hash.update(entry.relativePath);
+      hash.update(entry.specifier);
       hash.update(entry.content);
     }
   } else {
@@ -4947,7 +4956,7 @@ var resolveStrategyGateFingerprint = async ({
   }
   return {
     gateFingerprint: hash.digest("hex").slice(0, 16),
-    gateFingerprintFiles: sourceEntries.map((entry) => entry.relativePath)
+    gateFingerprintFiles: sourceEntries.map((entry) => entry.specifier)
   };
 };
 
@@ -5126,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,
@@ -5168,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",
@@ -5421,6 +5445,7 @@ var runHistoricalSignalsReplay = async ({
               userName: replayUserName,
               connectorName,
               runtimeConfigId: "config",
+              runtimeLineage,
               config: buildReplayStrategyConfig({
                 strategyConfig,
                 interval
@@ -7201,6 +7226,7 @@ var buildRuntimeEvidenceLineageScopes = ({
     strategy,
     symbol,
     runtimeConfigId,
+    runtimeReleaseVersion,
     timestamp,
     lineage
   }) => {
@@ -7213,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
@@ -7223,6 +7250,7 @@ var buildRuntimeEvidenceLineageScopes = ({
       strategy: signal.strategy,
       symbol: signal.symbol,
       runtimeConfigId: signal.runtimeConfigId,
+      runtimeReleaseVersion: signal.runtimeReleaseVersion,
       timestamp: signal.timestamp,
       lineage: signal.runtimeLineage
     });
@@ -7232,6 +7260,7 @@ var buildRuntimeEvidenceLineageScopes = ({
       strategy: evaluation.strategy,
       symbol: evaluation.symbol,
       runtimeConfigId: evaluation.runtimeConfigId,
+      runtimeReleaseVersion: evaluation.runtimeReleaseVersion,
       timestamp: evaluation.timestamp,
       lineage: evaluation.runtimeLineage
     });
@@ -8542,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) => {