@tradejs/cli 3.1.15-beta.228 → 3.1.15

package/dist/scripts/runtimeEvidence.js

@@ -639,7 +639,74 @@ var runtimeLineageKey = (lineage) => lineage.schemaVersion === 3 ? [
 
 // src/lib/runtimeEvidenceDeployment.ts
 var import_runtimeStrategies = require("@tradejs/node/runtimeStrategies");
+var isNonEmptyString = (value) => typeof value === "string" && value.trim().length > 0;
+var samePackageVersions = (left, right) => {
+  if (!left || !right) return false;
+  const leftEntries = Object.entries(left).sort(
+    ([a], [b]) => a.localeCompare(b)
+  );
+  const rightEntries = Object.entries(right).sort(
+    ([a], [b]) => a.localeCompare(b)
+  );
+  return JSON.stringify(leftEntries) === JSON.stringify(rightEntries);
+};
+var lineageMatchesStrategySnapshot = ({
+  lineage,
+  deployment,
+  strategy
+}) => lineage?.schemaVersion === 3 && lineage.strategyRevision === strategy.strategyRevision && lineage.deploymentCompositionId === deployment.deploymentCompositionId && lineage.strategyPackageVersion === strategy.strategyPackageVersion && lineage.runtimePackageVersion === strategy.runtimePackageVersion && samePackageVersions(
+  lineage.strategyDependencyVersions,
+  strategy.strategyDependencyVersions
+);
 var activeRuntimeEvidenceStrategies = (deployment) => deployment.enabled ? deployment.strategies.filter((strategy) => strategy.enabled) : [];
+var resolveRuntimeEvidenceTickerUniverse = ({
+  deployment,
+  lineageScopes
+}) => {
+  const declaredTickers = deployment.tickers?.filter(isNonEmptyString) ?? [];
+  if (declaredTickers.length > 0) {
+    return {
+      ...deployment,
+      tickers: [
+        ...new Set(declaredTickers.map((ticker) => ticker.trim()))
+      ].sort()
+    };
+  }
+  const activeStrategies = activeRuntimeEvidenceStrategies(deployment);
+  if (activeStrategies.length > 0 && activeStrategies.every((strategy) => strategy.selection?.tickers?.length)) {
+    return {
+      ...deployment,
+      tickers: [
+        ...new Set(
+          activeStrategies.flatMap(
+            (strategy) => strategy.selection?.tickers ?? []
+          )
+        )
+      ].sort()
+    };
+  }
+  const strategiesByName = new Map(
+    activeStrategies.map((strategy) => [strategy.strategyName, strategy])
+  );
+  const tickers = /* @__PURE__ */ new Set();
+  for (const scope of lineageScopes) {
+    const strategy = strategiesByName.get(scope.strategy);
+    if (!strategy || scope.deploymentId !== deployment.id || scope.accountId !== deployment.accountId || !isNonEmptyString(scope.symbol) || !lineageMatchesStrategySnapshot({
+      lineage: scope.lineage,
+      deployment,
+      strategy
+    })) {
+      continue;
+    }
+    tickers.add(scope.symbol.trim());
+  }
+  if (tickers.size === 0) {
+    throw new Error(
+      "Runtime evidence has no immutable ticker universe for the embedded deployment composition"
+    );
+  }
+  return { ...deployment, tickers: [...tickers].sort() };
+};
 var resolveRuntimeEvidenceDeploymentSnapshot = async ({
   userName,
   projectRoot: projectRoot2,
@@ -777,18 +844,18 @@ var parseStrategyFilter = (value) => String(value ?? "").split(",").map((item) =
 var runtimeEvidence = async () => {
   const { startTime, endTime, source } = resolveWindow();
   const deploymentId = String(flags.deployment);
-  const deployment = await resolveRuntimeEvidenceDeploymentSnapshot({
+  const deploymentSnapshot = await resolveRuntimeEvidenceDeploymentSnapshot({
     userName: String(flags.user),
     projectRoot,
     deploymentId
   });
-  const activeStrategies = activeRuntimeEvidenceStrategies(deployment).map(
-    ({ strategyName }) => strategyName
-  );
+  const activeStrategies = activeRuntimeEvidenceStrategies(
+    deploymentSnapshot
+  ).map(({ strategyName }) => strategyName);
   const requestedStrategies = parseStrategyFilter(flags.strategy);
   const strategies = requestedStrategies.length ? requestedStrategies : activeStrategies;
   const declaredStrategies = new Set(
-    deployment.strategies.map(({ strategyName }) => strategyName)
+    deploymentSnapshot.strategies.map(({ strategyName }) => strategyName)
   );
   const unknownStrategies = strategies.filter(
     (strategyName) => !declaredStrategies.has(strategyName)
@@ -816,6 +883,10 @@ var runtimeEvidence = async () => {
     evaluationStatsBuckets: evidence.evaluationStatsBuckets,
     lineageScopes: evidence.lineageScopes
   });
+  const deployment = resolveRuntimeEvidenceTickerUniverse({
+    deployment: deploymentSnapshot,
+    lineageScopes: evidence.lineageScopes
+  });
   const artifact = {
     reportType: "runtime-evidence",
     generatedAt: Date.now(),

package/dist/scripts/runtimeEvidenceSync.js

@@ -151,6 +151,70 @@ var discoverRuntimeEvidenceBundles = async (rootDir) => {
   return bundles.sort();
 };
 
+// src/lib/runtimeEvidenceDeployment.ts
+var import_runtimeStrategies = require("@tradejs/node/runtimeStrategies");
+var isRecord = (value) => value != null && typeof value === "object" && !Array.isArray(value);
+var isNonEmptyString = (value) => typeof value === "string" && value.trim().length > 0;
+var isPackageVersionMap = (value) => isRecord(value) && Object.keys(value).length > 0 && Object.entries(value).every(
+  ([name, version]) => name.startsWith("@tradejs/") && isNonEmptyString(version)
+);
+var INTERVALS = /* @__PURE__ */ new Set([
+  "1",
+  "3",
+  "5",
+  "15",
+  "30",
+  "60",
+  "120",
+  "240",
+  "360",
+  "720",
+  "D",
+  "W",
+  "M"
+]);
+var UNIVERSES = /* @__PURE__ */ new Set(["crypto", "tradfi"]);
+var isRuntimeStrategySelection = (value) => value === void 0 || isRecord(value) && Object.keys(value).length === 1 && Object.keys(value).every((key) => key === "tickers") && Array.isArray(value.tickers) && value.tickers.length > 0 && value.tickers.every((ticker) => isNonEmptyString(ticker));
+var parseRuntimeEvidenceDeploymentSnapshot = (value) => {
+  if (!isRecord(value) || value.schemaVersion !== 2 || !isNonEmptyString(value.id) || !isNonEmptyString(value.deploymentCompositionId) || !/^dc1:[a-f0-9]{16}$/.test(value.deploymentCompositionId) || !isNonEmptyString(value.label) || !isNonEmptyString(value.connectorName) || !isNonEmptyString(value.provider) || !isNonEmptyString(value.accountId) || typeof value.enabled !== "boolean" || !Array.isArray(value.strategies)) {
+    throw new Error(
+      "Runtime evidence deployment snapshot is missing or invalid"
+    );
+  }
+  const strategies = value.strategies.map((candidate) => {
+    if (!isRecord(candidate) || !isNonEmptyString(candidate.strategyName) || !isNonEmptyString(candidate.strategyRevision) || !/^sr1:[a-f0-9]{16}$/.test(candidate.strategyRevision) || typeof candidate.enabled !== "boolean" || !["active", "entries_paused"].includes(String(candidate.controlState)) || !INTERVALS.has(String(candidate.interval)) || !UNIVERSES.has(String(candidate.universe)) || !isNonEmptyString(candidate.strategyPackage) || !isNonEmptyString(candidate.strategyPackageVersion) || !isPackageVersionMap(candidate.strategyDependencyVersions) || !isNonEmptyString(candidate.runtimePackageVersion) || !isRecord(candidate.strategyConfig) || !isRuntimeStrategySelection(candidate.selection)) {
+      throw new Error(
+        "Runtime evidence deployment strategy snapshot is invalid"
+      );
+    }
+    if (String(candidate.strategyConfig.INTERVAL) !== String(candidate.interval) || String(candidate.strategyConfig.UNIVERSE) !== String(candidate.universe)) {
+      throw new Error(
+        `Runtime evidence strategy config does not match its scope: ${candidate.strategyName}`
+      );
+    }
+    if (candidate.accountId != null && (!isNonEmptyString(candidate.accountId) || candidate.accountId !== value.accountId)) {
+      throw new Error(
+        `Runtime evidence strategy account does not match deployment: ${candidate.strategyName}`
+      );
+    }
+    return candidate;
+  });
+  const identities = /* @__PURE__ */ new Set();
+  for (const strategy of strategies) {
+    if (identities.has(strategy.strategyName)) {
+      throw new Error(
+        `Duplicate runtime evidence strategy: ${strategy.strategyName}`
+      );
+    }
+    identities.add(strategy.strategyName);
+  }
+  return {
+    ...value,
+    strategies
+  };
+};
+var activeRuntimeEvidenceStrategies = (deployment) => deployment.enabled ? deployment.strategies.filter((strategy) => strategy.enabled) : [];
+
 // src/lib/runtimeEvidenceSync.ts
 var execFileAsync = (0, import_node_util.promisify)(import_node_child_process.execFile);
 var isExistingDestinationError = (error) => {
@@ -183,7 +247,26 @@ var buildRuntimeEvidenceRsyncArgs = ({
   withTrailingSlash(destination)
 ];
 var receiptPath = (receiptsRoot, artifactId) => import_node_path2.default.join(receiptsRoot, `${safeSegment(artifactId, "artifact")}.json`);
-var listPendingRuntimeEvidenceBundles = async ({
+var compareBundles = (left, right) => left.manifest.window.endTime - right.manifest.window.endTime || left.manifest.createdAt - right.manifest.createdAt;
+var inspectRuntimeEvidenceBundleSupport = (bundle) => {
+  try {
+    const deployment = parseRuntimeEvidenceDeploymentSnapshot(
+      bundle.artifact.deployment
+    );
+    if (activeRuntimeEvidenceStrategies(deployment).length === 0) {
+      throw new Error(
+        "Runtime evidence deployment has no enabled active strategies"
+      );
+    }
+    return { supported: true };
+  } catch (error) {
+    return {
+      supported: false,
+      reason: error instanceof Error ? error.message : String(error)
+    };
+  }
+};
+var listRuntimeEvidenceBundleStatuses = async ({
   evidenceRoot,
   deploymentId
 }) => {
@@ -192,19 +275,29 @@ var listPendingRuntimeEvidenceBundles = async ({
   const receiptsRoot = import_node_path2.default.join(evidenceRoot, "receipts", safeDeploymentId);
   const bundles = await discoverRuntimeEvidenceBundles(artifactsRoot);
   const pending = [];
+  const unsupported = [];
   for (const bundleDir of bundles) {
     const verified = await verifyRuntimeEvidenceBundle(bundleDir);
     if (verified.manifest.deploymentId !== safeDeploymentId) continue;
     try {
       await import_promises2.default.access(receiptPath(receiptsRoot, verified.manifest.artifactId));
+      continue;
     } catch (error) {
       if (error.code !== "ENOENT") throw error;
+    }
+    const support = inspectRuntimeEvidenceBundleSupport(verified);
+    if (support.supported) {
       pending.push(verified);
+    } else {
+      unsupported.push({ bundle: verified, reason: support.reason });
     }
   }
-  return pending.sort(
-    (left, right) => left.manifest.window.startTime - right.manifest.window.startTime || left.manifest.createdAt - right.manifest.createdAt
-  );
+  return {
+    pending: pending.sort(compareBundles),
+    unsupported: unsupported.sort(
+      (left, right) => compareBundles(left.bundle, right.bundle)
+    )
+  };
 };
 var syncRuntimeEvidenceBundles = async ({
   source,
@@ -258,15 +351,16 @@ var syncRuntimeEvidenceBundles = async ({
     }
     received.push(await verifyRuntimeEvidenceBundle(destinationDir));
   }
+  const statuses = await listRuntimeEvidenceBundleStatuses({
+    evidenceRoot,
+    deploymentId: safeDeploymentId
+  });
   return {
     rsyncArgs,
     stdout: String(transfer.stdout ?? ""),
     stderr: String(transfer.stderr ?? ""),
     received,
-    pending: await listPendingRuntimeEvidenceBundles({
-      evidenceRoot,
-      deploymentId: safeDeploymentId
-    })
+    ...statuses
   };
 };
 
@@ -303,7 +397,7 @@ var runtimeEvidenceSync = async () => {
   });
   console.log(
     import_chalk.default.green(
-      `Runtime evidence sync completed: received=${result.received.length} pending=${result.pending.length}`
+      `Runtime evidence sync completed: received=${result.received.length} pending=${result.pending.length} unsupported=${result.unsupported.length}`
     )
   );
   console.log(
@@ -320,6 +414,13 @@ var runtimeEvidenceSync = async () => {
           bundleDir: bundle.bundleDir,
           payloadPath: bundle.payloadPath,
           window: bundle.manifest.window
+        })),
+        unsupported: result.unsupported.map(({ bundle, reason }) => ({
+          artifactId: bundle.manifest.artifactId,
+          bundleDir: bundle.bundleDir,
+          payloadPath: bundle.payloadPath,
+          window: bundle.manifest.window,
+          reason
         }))
       },
       null,

package/dist/scripts/runtimeScorecard.js

@@ -152,6 +152,11 @@ var import_node_child_process = require("child_process");
 var import_promises2 = __toESM(require("fs/promises"));
 var import_node_path2 = __toESM(require("path"));
 var import_node_util = require("util");
+
+// src/lib/runtimeEvidenceDeployment.ts
+var import_runtimeStrategies = require("@tradejs/node/runtimeStrategies");
+
+// src/lib/runtimeEvidenceSync.ts
 var execFileAsync = (0, import_node_util.promisify)(import_node_child_process.execFile);
 var safeSegment = (value, fallback) => {
   const normalized = value.trim().replace(/[^a-zA-Z0-9._-]+/g, "-");
@@ -346,6 +351,138 @@ var buildRuntimeLineageSummary = (rows) => {
     maxLossValue: finiteNumber(identity?.maxLossValue)
   };
 };
+var buildEmbeddedLineageScope = ({
+  artifact,
+  rows,
+  strategy
+}) => {
+  const deployment = asRecord2(asRecord2(artifact)?.deployment);
+  if (finiteNumber(deployment?.schemaVersion) !== 2) return null;
+  const deploymentId = finiteString(deployment?.id);
+  const accountId = finiteString(deployment?.accountId);
+  const deploymentCompositionId = finiteString(
+    deployment?.deploymentCompositionId
+  );
+  if (!deploymentId || !accountId || !deploymentCompositionId) return null;
+  const snapshots = asArray(deployment?.strategies).map(asRecord2).filter((item) => item != null).filter((item) => item.enabled === true).filter(
+    (item) => !strategy || finiteString(item.strategyName) === strategy
+  );
+  const targetSeeds = snapshots.map((snapshot) => {
+    const strategyName = finiteString(snapshot.strategyName);
+    const strategyRevision = finiteString(snapshot.strategyRevision);
+    const strategyPackageVersion = finiteString(
+      snapshot.strategyPackageVersion
+    );
+    const strategyDependencyVersions = packageVersionMap(
+      snapshot.strategyDependencyVersions
+    );
+    const runtimePackageVersion = finiteString(
+      snapshot.runtimePackageVersion
+    );
+    return strategyName && strategyRevision && strategyPackageVersion && strategyDependencyVersions && runtimePackageVersion ? {
+      strategyName,
+      strategyRevision,
+      deploymentCompositionId,
+      strategyPackageVersion,
+      strategyDependencyVersions,
+      runtimePackageVersion
+    } : null;
+  }).filter((item) => item != null);
+  if (targetSeeds.length !== snapshots.length || targetSeeds.length === 0) {
+    return null;
+  }
+  const lineageRows = [
+    ...rows.evaluations,
+    ...rows.signals,
+    ...rows.trades,
+    ...rows.lineageScopes.map((scope) => ({
+      strategy: scope.strategy,
+      deploymentId: scope.deploymentId,
+      accountId: scope.accountId,
+      runtimeLineage: scope.lineage
+    }))
+  ];
+  const identityMatches = (lineage, target) => finiteNumber(lineage?.schemaVersion) === 3 && finiteString(lineage?.strategyRevision) === target.strategyRevision && finiteString(lineage?.deploymentCompositionId) === target.deploymentCompositionId && finiteString(lineage?.strategyPackageVersion) === target.strategyPackageVersion && JSON.stringify(packageVersionMap(lineage?.strategyDependencyVersions)) === JSON.stringify(target.strategyDependencyVersions) && finiteString(lineage?.runtimePackageVersion) === target.runtimePackageVersion;
+  const targets = /* @__PURE__ */ new Map();
+  for (const seed of targetSeeds) {
+    const matchingRows = lineageRows.filter(
+      (row) => finiteString(row.strategy) === seed.strategyName && finiteString(row.deploymentId) === deploymentId && finiteString(row.accountId) === accountId && identityMatches(asRecord2(row.runtimeLineage), seed)
+    );
+    const riskValues = new Set(
+      matchingRows.map((row) => finiteNumber(asRecord2(row.runtimeLineage)?.maxLossValue)).filter((value) => value != null)
+    );
+    targets.set(seed.strategyName, {
+      ...seed,
+      maxLossValue: riskValues.size === 1 ? [...riskValues][0] : null,
+      rowsWithLineage: matchingRows.length,
+      riskConflict: riskValues.size > 1
+    });
+  }
+  const belongs = (row) => {
+    const strategyName = finiteString(row.strategy);
+    const target = strategyName ? targets.get(strategyName) : null;
+    const lineage = asRecord2(row.runtimeLineage);
+    return Boolean(
+      target && target.maxLossValue != null && identityMatches(lineage, target) && finiteNumber(lineage?.maxLossValue) === target.maxLossValue
+    );
+  };
+  const targetValues = [...targets.values()];
+  const coverageComplete = targetValues.every(
+    (target) => target.rowsWithLineage > 0 && target.maxLossValue != null
+  );
+  const commonRiskValues = new Set(
+    targetValues.map((target) => target.maxLossValue).filter((value) => value != null)
+  );
+  const singleTarget = targetValues.length === 1 ? targetValues[0] : null;
+  const singleLineage = singleTarget?.maxLossValue != null ? {
+    schemaVersion: 3,
+    strategyRevision: singleTarget.strategyRevision,
+    deploymentCompositionId: singleTarget.deploymentCompositionId,
+    strategyPackageVersion: singleTarget.strategyPackageVersion,
+    strategyDependencyVersions: singleTarget.strategyDependencyVersions,
+    runtimePackageVersion: singleTarget.runtimePackageVersion,
+    maxLossValue: singleTarget.maxLossValue
+  } : null;
+  return {
+    belongs,
+    summary: {
+      complete: coverageComplete,
+      identityComplete: true,
+      coverageComplete,
+      conflicts: targetValues.some((target) => target.riskConflict),
+      rows: lineageRows.length,
+      rowsWithLineage: targetValues.reduce(
+        (total, target) => total + target.rowsWithLineage,
+        0
+      ),
+      schemaVersion: 3,
+      lineageKey: singleLineage ? runtimeLineageKey(singleLineage) : null,
+      strategyRevision: singleTarget?.strategyRevision ?? null,
+      deploymentCompositionId,
+      strategyPackageVersion: singleTarget?.strategyPackageVersion ?? null,
+      strategyDependencyVersions: singleTarget?.strategyDependencyVersions ?? null,
+      runtimePackageVersion: singleTarget?.runtimePackageVersion ?? null,
+      compositionId: null,
+      gitSha: null,
+      gitDirty: null,
+      gateFingerprint: null,
+      configFingerprint: null,
+      contextFingerprint: null,
+      maxLossValue: commonRiskValues.size === 1 ? [...commonRiskValues][0] : null,
+      strategyScopes: Object.fromEntries(
+        targetValues.map((target) => [
+          target.strategyName,
+          {
+            strategyRevision: target.strategyRevision,
+            rowsWithLineage: target.rowsWithLineage,
+            maxLossValue: target.maxLossValue,
+            complete: target.rowsWithLineage > 0 && target.maxLossValue != null
+          }
+        ])
+      )
+    }
+  };
+};
 var belongsToRuntimeLineage = (row, summary) => {
   if (!summary.identityComplete || !summary.lineageKey) return false;
   const lineage = asRecord2(row.runtimeLineage);
@@ -571,7 +708,12 @@ var buildRuntimeScorecard = ({
   );
   const deploymentBinding = runtimeDeploymentBinding(runtimeArtifact);
   const rows = extractRuntimeRows(scopedRuntimeArtifact);
-  const runtimeLineage = buildRuntimeLineageSummary(rows);
+  const embeddedLineageScope = buildEmbeddedLineageScope({
+    artifact: runtimeArtifact,
+    rows,
+    strategy
+  });
+  const runtimeLineage = embeddedLineageScope?.summary ?? buildRuntimeLineageSummary(rows);
   const window = runtimeWindow(runtimeArtifact);
   const startTime = finiteNumber(window.startTime) ?? generatedAt - 864e5;
   const endTime = finiteNumber(window.endTime) ?? generatedAt;
@@ -620,12 +762,17 @@ var buildRuntimeScorecard = ({
   const lineageReason = finiteString(lineage?.reason);
   const calibrationRoot = asRecord2(calibrationArtifact) ?? {};
   const calibrationSummary = asRecord2(calibrationRoot.summary);
-  const calibration = strategy ? asRecord2(asRecord2(calibrationSummary?.byStrategy)?.[strategy]) : getCalibrationSummary(calibrationArtifact);
-  const actualSlippageBps = finiteNumber(
-    asRecord2(calibration?.signalToFillAdverseBps)?.avg
+  const calibrationSamples = asArray(calibrationRoot.samples).map(asRecord2).filter((item) => item != null).filter((item) => !strategy || finiteString(item.strategy) === strategy).filter(
+    (item) => !embeddedLineageScope || embeddedLineageScope.belongs(item)
   );
-  const residualVsModelBps = finiteNumber(
-    asRecord2(calibration?.residualVsCurrentModelBps)?.avg
+  const averageSampleMetric = (field) => {
+    const values = calibrationSamples.map((sample) => finiteNumber(sample[field])).filter((value) => value != null);
+    return values.length ? round(sum(values) / values.length) : null;
+  };
+  const fallbackCalibration = strategy ? asRecord2(asRecord2(calibrationSummary?.byStrategy)?.[strategy]) : getCalibrationSummary(calibrationArtifact);
+  const actualSlippageBps = embeddedLineageScope ? averageSampleMetric("signalToFillAdverseBps") : finiteNumber(asRecord2(fallbackCalibration?.signalToFillAdverseBps)?.avg);
+  const residualVsModelBps = embeddedLineageScope ? averageSampleMetric("residualVsCurrentModelBps") : finiteNumber(
+    asRecord2(fallbackCalibration?.residualVsCurrentModelBps)?.avg
   );
   const prospective = getProspectiveSummary(prospectiveEvidenceArtifact);
   const historyTrades = dedupeTrades([
@@ -633,10 +780,13 @@ var buildRuntimeScorecard = ({
     scopedRuntimeArtifact
   ]);
   const comparableHistoryTrades = historyTrades.filter(
-    (trade) => belongsToRuntimeDeployment(trade, deploymentBinding) && belongsToRuntimeLineage(trade, runtimeLineage)
+    (trade) => belongsToRuntimeDeployment(trade, deploymentBinding) && (embeddedLineageScope ? embeddedLineageScope.belongs(trade) : belongsToRuntimeLineage(trade, runtimeLineage))
   );
   const comparableCurrentClosedTrades = currentClosedTrades.filter(
-    (trade) => belongsToRuntimeDeployment(trade, deploymentBinding) && belongsToRuntimeLineage(trade, runtimeLineage)
+    (trade) => belongsToRuntimeDeployment(trade, deploymentBinding) && (embeddedLineageScope ? embeddedLineageScope.belongs(trade) : belongsToRuntimeLineage(trade, runtimeLineage))
+  );
+  const comparableFills = rows.trades.filter(
+    (trade) => belongsToRuntimeDeployment(trade, deploymentBinding) && (embeddedLineageScope ? embeddedLineageScope.belongs(trade) : belongsToRuntimeLineage(trade, runtimeLineage))
   );
   const currentDistributions = buildDistributions(rows);
   const previousArtifact = scopedHistoryArtifacts.map((artifact) => ({ artifact, window: runtimeWindow(artifact) })).filter(({ window: candidateWindow }) => {
@@ -750,7 +900,8 @@ var buildRuntimeScorecard = ({
           `${finiteString(signal.orderSkipReason) ?? ""} ${finiteString(signal.orderFailureReason) ?? ""}`
         )
       ).length,
-      fills: rows.trades.length,
+      fills: comparableFills.length,
+      nonComparableFills: rows.trades.length - comparableFills.length,
       closedTrades: currentClosedTrades.length,
       comparableClosedTrades: comparableCurrentClosedTrades.length,
       nonComparableClosedTrades: currentClosedTrades.length - comparableCurrentClosedTrades.length
@@ -799,7 +950,7 @@ var buildRuntimeScorecard = ({
       lineageReason
     },
     execution: {
-      available: calibration != null,
+      available: actualSlippageBps != null || residualVsModelBps != null,
       actualSignalToFillSlippageBps: actualSlippageBps,
       residualVsCurrentModelBps: residualVsModelBps
     },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tradejs/cli",
-  "version": "3.1.15-beta.228",
+  "version": "3.1.15",
   "description": "Official CLI for the TradeJS TypeScript framework: infra setup, backtests, signals, bots, and ML workflows.",
   "keywords": [
     "tradejs",
@@ -36,13 +36,13 @@
     "tradejs": "dist/cli.js"
   },
   "dependencies": {
-    "@tradejs/connectors": "^3.1.15-beta.228",
-    "@tradejs/core": "^3.1.15-beta.228",
-    "@tradejs/indicators": "^3.1.15-beta.228",
-    "@tradejs/infra": "^3.1.15-beta.228",
-    "@tradejs/node": "^3.1.15-beta.228",
+    "@tradejs/connectors": "^3.1.15",
+    "@tradejs/core": "^3.1.15",
+    "@tradejs/indicators": "^3.1.15",
+    "@tradejs/infra": "^3.1.15",
+    "@tradejs/node": "^3.1.15",
     "@tradejs/strategy-kit": "3.0.3",
-    "@tradejs/types": "^3.1.15-beta.228",
+    "@tradejs/types": "^3.1.15",
     "args": "^5.0.3",
     "bcryptjs": "^2.4.3",
     "chalk": "4.1.2",