@tradejs/cli 3.0.1 → 3.1.1

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 } : {}
 });
@@ -4913,28 +4913,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
   );
@@ -4942,7 +4951,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 {
@@ -4950,7 +4959,7 @@ var resolveStrategyGateFingerprint = async ({
   }
   return {
     gateFingerprint: hash.digest("hex").slice(0, 16),
-    gateFingerprintFiles: sourceEntries.map((entry) => entry.relativePath)
+    gateFingerprintFiles: sourceEntries.map((entry) => entry.specifier)
   };
 };
 
@@ -5129,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,
@@ -5171,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",
@@ -5424,6 +5448,7 @@ var runHistoricalSignalsReplay = async ({
               userName: replayUserName,
               connectorName,
               runtimeConfigId: "config",
+              runtimeLineage,
               config: buildReplayStrategyConfig({
                 strategyConfig,
                 interval
@@ -7204,6 +7229,7 @@ var buildRuntimeEvidenceLineageScopes = ({
     strategy,
     symbol,
     runtimeConfigId,
+    runtimeReleaseVersion,
     timestamp,
     lineage
   }) => {
@@ -7216,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
@@ -7226,6 +7253,7 @@ var buildRuntimeEvidenceLineageScopes = ({
       strategy: signal.strategy,
       symbol: signal.symbol,
       runtimeConfigId: signal.runtimeConfigId,
+      runtimeReleaseVersion: signal.runtimeReleaseVersion,
       timestamp: signal.timestamp,
       lineage: signal.runtimeLineage
     });
@@ -7235,6 +7263,7 @@ var buildRuntimeEvidenceLineageScopes = ({
       strategy: evaluation.strategy,
       symbol: evaluation.symbol,
       runtimeConfigId: evaluation.runtimeConfigId,
+      runtimeReleaseVersion: evaluation.runtimeReleaseVersion,
       timestamp: evaluation.timestamp,
       lineage: evaluation.runtimeLineage
     });
@@ -8545,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,12 +57,12 @@ 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");
 var import_redis2 = require("@tradejs/infra/redis");
-var import_strategies = require("@tradejs/strategies");
+var import_registry = require("@tradejs/node/registry");
 
 // src/lib/runtimeRedis.ts
 var import_redis = require("@tradejs/infra/redis");
@@ -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 = {
@@ -762,7 +783,7 @@ var main = async () => {
       target.strategy
     );
     const backtestConfigKey = import_redis2.redisKeys.backtestConfig(userName, target.config);
-    const defaults = (0, import_strategies.getBuiltInStrategyDefaultConfig)(target.strategy) || {};
+    const defaults = await (0, import_registry.getStrategyDefaults)(target.strategy, projectRoot) || {};
     const userStrategyConfig = await (0, import_redis2.getData)(
       strategyConfigKey,
       {}

package/dist/scripts/runtimeConfig.js

@@ -0,0 +1,290 @@
+"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/runtimeConfig.ts
+var runtimeConfig_exports = {};
+__export(runtimeConfig_exports, {
+  main: () => main,
+  runtimeConfig: () => runtimeConfig
+});
+module.exports = __toCommonJS(runtimeConfig_exports);
+var import_config = require("dotenv/config");
+var import_promises = require("fs/promises");
+var import_node_path = __toESM(require("path"));
+var import_runtimeDeployments = require("@tradejs/infra/runtimeDeployments");
+var import_runtimeStrategyConfigs = require("@tradejs/infra/runtimeStrategyConfigs");
+var import_runtimeStrategyReleases = require("@tradejs/infra/runtimeStrategyReleases");
+var import_runtimeStrategies = require("@tradejs/node/runtimeStrategies");
+var import_strategies = require("@tradejs/node/strategies");
+var argv = process.argv.slice(2);
+var action = argv[0] ?? "inspect";
+var option = (name) => {
+  const index = argv.indexOf(`--${name}`);
+  return index >= 0 ? argv[index + 1] : void 0;
+};
+var hasFlag = (name) => argv.includes(`--${name}`);
+var required = (name) => {
+  const value = String(option(name) ?? "").trim();
+  if (!value) throw new Error(`--${name} is required`);
+  return value;
+};
+var projectRoot = String(process.env.PROJECT_CWD || process.cwd()).trim() || process.cwd();
+var userName = String(option("user") ?? process.env.USER_NAME ?? "root");
+var OPERATIONAL_CONFIG_KEYS = [
+  "ACCOUNT_ID",
+  "AI_REPLAY_ANALYSES",
+  "DEPLOYMENT_ID",
+  "ENABLE",
+  "ENV",
+  "MAKE_ORDERS",
+  "RECORD_RUNTIME_TRADES",
+  "configId"
+];
+var toReleaseConfig = async (strategyName, sourceConfig) => {
+  const defaults = await (0, import_strategies.getStrategyDefaults)(strategyName, projectRoot) ?? {};
+  const config = { ...defaults, ...sourceConfig };
+  for (const key of OPERATIONAL_CONFIG_KEYS) delete config[key];
+  return config;
+};
+var writeMigrationBackup = async (payload) => {
+  const directory = import_node_path.default.join(projectRoot, "data", "runtime-config-backups");
+  await (0, import_promises.mkdir)(directory, { recursive: true });
+  const backupPath = import_node_path.default.join(
+    directory,
+    `${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}.json`
+  );
+  await (0, import_promises.writeFile)(backupPath, `${JSON.stringify(payload, null, 2)}
+`, {
+    flag: "wx"
+  });
+  return backupPath;
+};
+var publish = async ({
+  strategyName,
+  sourceConfig
+}) => {
+  const config = await toReleaseConfig(strategyName, sourceConfig);
+  const metadata = await (0, import_runtimeStrategies.getRuntimeStrategyPackageMetadata)({
+    strategyName,
+    projectRoot
+  });
+  return (0, import_runtimeStrategyReleases.publishRuntimeStrategyRelease)({
+    userName,
+    strategyName,
+    config,
+    ...metadata,
+    createdBy: `cli:${userName}`
+  });
+};
+var migrate = async () => {
+  const strategyName = required("strategy");
+  const configId = option("config") ?? "config";
+  const deploymentId = required("deployment");
+  const [sourceConfig, deployment] = await Promise.all([
+    (0, import_runtimeStrategyConfigs.getRuntimeStrategyConfig)(userName, strategyName, configId),
+    (0, import_runtimeDeployments.getRuntimeDeployment)(userName, deploymentId)
+  ]);
+  if (!sourceConfig) {
+    throw new Error(`Legacy config not found: ${strategyName}:${configId}`);
+  }
+  if (!deployment) throw new Error(`Deployment not found: ${deploymentId}`);
+  const reference = deployment.strategies.find(
+    (strategy) => strategy.strategyName === strategyName
+  );
+  if (!reference) {
+    throw new Error(`${strategyName} is not bound to ${deploymentId}`);
+  }
+  const preview = {
+    source: { configId, config: sourceConfig },
+    releaseConfig: await toReleaseConfig(strategyName, sourceConfig),
+    deployment: {
+      id: deployment.id,
+      accountId: deployment.accountId,
+      strategy: {
+        strategyName,
+        releaseVersion: "<allocated on write>",
+        controlState: "entries_paused"
+      }
+    }
+  };
+  if (!hasFlag("write")) {
+    console.log(JSON.stringify({ dryRun: true, ...preview }, null, 2));
+    return;
+  }
+  const backupPath = await writeMigrationBackup({
+    userName,
+    capturedAt: Date.now(),
+    deployment,
+    legacyConfig: sourceConfig
+  });
+  const release = await publish({ strategyName, sourceConfig });
+  const updatedDeployment = {
+    ...deployment,
+    strategies: deployment.strategies.map(
+      (strategy) => strategy.strategyName === strategyName ? {
+        strategyName,
+        releaseVersion: release.releaseVersion,
+        controlState: "entries_paused"
+      } : strategy
+    )
+  };
+  await (0, import_runtimeDeployments.saveRuntimeDeployment)(userName, updatedDeployment);
+  console.log(
+    JSON.stringify(
+      { migrated: true, backupPath, release, deployment: updatedDeployment },
+      null,
+      2
+    )
+  );
+};
+var publishDraft = async () => {
+  const strategyName = required("strategy");
+  const draft = await (0, import_runtimeStrategyReleases.getRuntimeStrategyDraft)(userName, strategyName);
+  if (!draft) throw new Error(`Draft not found: ${strategyName}`);
+  const release = await publish({ strategyName, sourceConfig: draft.config });
+  console.log(JSON.stringify({ release }, null, 2));
+};
+var updateControlState = async (nextState) => {
+  const strategyName = required("strategy");
+  const deploymentId = required("deployment");
+  const deployment = await (0, import_runtimeDeployments.getRuntimeDeployment)(userName, deploymentId);
+  if (!deployment) throw new Error(`Deployment not found: ${deploymentId}`);
+  const reference = deployment.strategies.find(
+    (strategy) => strategy.strategyName === strategyName
+  );
+  if (!reference?.releaseVersion) {
+    throw new Error(`${strategyName} is not a versioned deployment reference`);
+  }
+  const previousState = reference.controlState ?? "active";
+  const updated = await (0, import_runtimeDeployments.saveRuntimeDeployment)(userName, {
+    ...deployment,
+    strategies: deployment.strategies.map(
+      (strategy) => strategy.strategyName === strategyName ? { ...strategy, controlState: nextState } : strategy
+    )
+  });
+  const event = previousState === nextState ? null : await (0, import_runtimeStrategyReleases.recordRuntimeStrategyControlEvent)({
+    userName,
+    deploymentId,
+    strategyName,
+    releaseVersion: reference.releaseVersion,
+    previousState,
+    nextState,
+    createdBy: `cli:${userName}`
+  });
+  console.log(JSON.stringify({ deployment: updated, event }, null, 2));
+};
+var rollback = async () => {
+  const strategyName = required("strategy");
+  const deploymentId = required("deployment");
+  const releaseVersion = Number(required("release"));
+  if (!Number.isSafeInteger(releaseVersion) || releaseVersion <= 0) {
+    throw new Error("--release must be a positive integer");
+  }
+  const deployment = await (0, import_runtimeDeployments.getRuntimeDeployment)(userName, deploymentId);
+  if (!deployment) throw new Error(`Deployment not found: ${deploymentId}`);
+  const release = (await (0, import_runtimeStrategyReleases.listRuntimeStrategyReleases)(userName, strategyName)).find((candidate) => candidate.releaseVersion === releaseVersion);
+  if (!release)
+    throw new Error(`Release not found: ${strategyName} v${releaseVersion}`);
+  const backupPath = await writeMigrationBackup({
+    userName,
+    capturedAt: Date.now(),
+    deployment,
+    reason: "rollback"
+  });
+  const updated = await (0, import_runtimeDeployments.saveRuntimeDeployment)(userName, {
+    ...deployment,
+    strategies: deployment.strategies.map(
+      (strategy) => strategy.strategyName === strategyName ? {
+        strategyName,
+        releaseVersion,
+        controlState: "entries_paused"
+      } : strategy
+    )
+  });
+  console.log(JSON.stringify({ backupPath, deployment: updated }, null, 2));
+};
+var verify = async () => {
+  const deployments = await (0, import_runtimeDeployments.listRuntimeDeployments)(userName);
+  const selected = option("deployment") ? deployments.filter((deployment) => deployment.id === option("deployment")) : deployments;
+  const results = [];
+  for (const deployment of selected) {
+    try {
+      const strategies = await (0, import_runtimeStrategies.loadResolvedRuntimeStrategies)({
+        userName,
+        projectRoot,
+        deployment,
+        connectorName: deployment.connectorName
+      });
+      results.push({
+        deploymentId: deployment.id,
+        ok: true,
+        strategies: strategies.map((strategy) => ({
+          strategyName: strategy.strategyName,
+          releaseVersion: strategy.releaseVersion,
+          controlState: strategy.controlState,
+          interval: strategy.interval,
+          universe: strategy.universe,
+          accountId: strategy.accountId
+        }))
+      });
+    } catch (error) {
+      results.push({
+        deploymentId: deployment.id,
+        ok: false,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  console.log(JSON.stringify({ userName, results }, null, 2));
+  if (results.some((result) => !result.ok)) process.exitCode = 1;
+};
+var inspect = async () => {
+  const strategyName = option("strategy");
+  const deployments = await (0, import_runtimeDeployments.listRuntimeDeployments)(userName);
+  const releases = strategyName ? await (0, import_runtimeStrategyReleases.listRuntimeStrategyReleases)(userName, strategyName) : void 0;
+  console.log(JSON.stringify({ userName, deployments, releases }, null, 2));
+};
+var runtimeConfig = async () => {
+  if (action === "migrate") return migrate();
+  if (action === "publish-draft") return publishDraft();
+  if (action === "verify") return verify();
+  if (action === "pause") return updateControlState("entries_paused");
+  if (action === "resume") return updateControlState("active");
+  if (action === "rollback") return rollback();
+  if (action === "inspect") return inspect();
+  throw new Error(
+    "Usage: tradejs runtime-config inspect|verify|migrate|publish-draft|pause|resume|rollback"
+  );
+};
+var main = runtimeConfig;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  main,
+  runtimeConfig
+});

package/dist/scripts/runtimeEvidence.js

@@ -568,11 +568,12 @@ var import_strategyReleaseEvidence = require("@tradejs/infra/strategyReleaseEvid
 
 // src/lib/strategyGateFingerprint.ts
 var import_node_crypto2 = require("crypto");
+var import_node_module = require("module");
 var import_promises2 = __toESM(require("fs/promises"));
 var import_node_path2 = __toESM(require("path"));
 
 // src/lib/runtimeLineage.ts
-var runtimeLineageKey = (lineage) => [
+var runtimeLineageKey = (lineage) => lineage.schemaVersion === 2 ? ["v2", lineage.releaseVersion].join(":") : [
   lineage.schemaVersion,
   lineage.compositionId ?? "unbound-composition",
   lineage.gitSha ?? "unknown",

package/dist/scripts/runtimeParity.js

@@ -4808,7 +4808,7 @@ var buildRuntimeModeStrategyConfig = ({
   ...strategyConfig,
   ENV: env,
   MAKE_ORDERS: makeOrders,
-  INTERVAL: interval2,
+  INTERVAL: strategyConfig.INTERVAL ?? interval2,
   ...typeof recordRuntimeTrades === "boolean" ? { RECORD_RUNTIME_TRADES: recordRuntimeTrades } : {},
   ...aiReplayAnalyses?.length ? { AI_REPLAY_ANALYSES: aiReplayAnalyses } : {}
 });