@tradejs/cli 2.0.19 → 2.0.20

package/dist/lib/executionCalibration.js

@@ -152,7 +152,8 @@ var extractRuntimeTradeRows = (runtimePayload) => {
     const signal = asRecord(redisValues?.signal) ?? (signalId ? signalsById.get(signalId) ?? null : null) ?? (shapeKey ? signalsByShape.get(shapeKey) ?? null : null);
     return {
       trade,
-      signal
+      signal,
+      runtimeLineage: asRecord(trade.runtimeLineage) ?? null
     };
   }).filter((row) => row != null);
 };
@@ -454,7 +455,8 @@ var buildSample = ({
       direction: direction ?? match?.direction ?? null,
       expectedPrice: match?.backtestPrice ?? null,
       actualPrice: match?.runtimePrice ?? null
-    })
+    }),
+    runtimeLineage: row.runtimeLineage
   };
 };
 var buildReplayOnlySample = (match) => ({
@@ -501,7 +503,8 @@ var buildReplayOnlySample = (match) => ({
     direction: match.direction,
     expectedPrice: match.backtestPrice,
     actualPrice: match.runtimePrice
-  })
+  }),
+  runtimeLineage: null
 });
 var hasTelemetry = (sample) => sample.signalClosePrice != null || sample.arrivalMid != null || sample.orderSubmitTime != null || sample.fillAvgPrice != null || sample.fillTime != null || sample.fee != null;
 var hasFullTelemetry = (sample) => sample.signalClosePrice != null && sample.arrivalMid != null && sample.orderSubmitTime != null && sample.orderAckTime != null && sample.fillAvgPrice != null && sample.fillTime != null;

package/dist/lib/runtimeLineage.js

@@ -38,11 +38,56 @@ __export(runtimeLineage_exports, {
 });
 module.exports = __toCommonJS(runtimeLineage_exports);
 var import_node_child_process = require("child_process");
+var import_node_crypto2 = require("crypto");
+var import_promises2 = __toESM(require("fs/promises"));
+var import_node_path2 = __toESM(require("path"));
+var import_types = require("@tradejs/types");
+var import_strategies = require("@tradejs/node/strategies");
+
+// src/lib/strategyGateFingerprint.ts
 var import_node_crypto = require("crypto");
 var import_promises = __toESM(require("fs/promises"));
 var import_node_path = __toESM(require("path"));
-var import_types = require("@tradejs/types");
-var import_strategies = require("@tradejs/node/strategies");
+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 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 sourceEntries = candidates.filter(
+    (entry) => entry != null
+  );
+  const hash = (0, import_node_crypto.createHash)("sha256");
+  hash.update(strategyName);
+  if (sourceEntries.length) {
+    for (const entry of sourceEntries) {
+      hash.update(entry.relativePath);
+      hash.update(entry.content);
+    }
+  } else {
+    hash.update(gitSha ?? "unknown-git-sha");
+  }
+  return {
+    gateFingerprint: hash.digest("hex").slice(0, 16),
+    gateFingerprintFiles: sourceEntries.map((entry) => entry.relativePath)
+  };
+};
+
+// src/lib/runtimeLineage.ts
 var RUNTIME_CONTEXT_ENV_KEYS = [
   "AI_MODE",
   "MIN_AI_QUALITY",
@@ -92,6 +137,17 @@ var normalizeForStableJson = (value) => {
   }
   return value;
 };
+var normalizeRuntimeLogicConfig = (value) => {
+  if (Array.isArray(value)) {
+    return value.map(normalizeRuntimeLogicConfig);
+  }
+  if (value && typeof value === "object") {
+    return Object.fromEntries(
+      Object.entries(value).filter(([key]) => key !== "MAX_LOSS_VALUE").sort(([left], [right]) => left.localeCompare(right)).map(([key, entry]) => [key, normalizeRuntimeLogicConfig(entry)])
+    );
+  }
+  return value;
+};
 var resolveRuntimeMaxLossValue = (config) => {
   if (!config || typeof config !== "object" || Array.isArray(config)) {
     return null;
@@ -105,7 +161,7 @@ var resolveRuntimeMaxLossValue = (config) => {
   );
   return Number.isFinite(maxLossValue) ? maxLossValue : null;
 };
-var fingerprintRuntimeValue = (value) => (0, import_node_crypto.createHash)("sha256").update(JSON.stringify(normalizeForStableJson(value))).digest("hex").slice(0, 16);
+var fingerprintRuntimeValue = (value) => (0, import_node_crypto2.createHash)("sha256").update(JSON.stringify(normalizeForStableJson(value))).digest("hex").slice(0, 16);
 var gitLineageCache = /* @__PURE__ */ new Map();
 var gateFingerprintCache = /* @__PURE__ */ new Map();
 var binanceBreadthFingerprintCache = /* @__PURE__ */ new Map();
@@ -156,7 +212,7 @@ var resolveGitLineage = (projectRoot) => {
 };
 var readOptionalFile = async (filePath) => {
   try {
-    return await import_promises.default.readFile(filePath);
+    return await import_promises2.default.readFile(filePath);
   } catch {
     return null;
   }
@@ -166,7 +222,7 @@ var resolveBinanceBreadthFingerprint = async (projectRoot) => {
     return binanceBreadthFingerprintCache.get(projectRoot) ?? null;
   }
   const content = await readOptionalFile(
-    import_node_path.default.join(
+    import_node_path2.default.join(
       projectRoot,
       "packages/node/src/config/binanceBreadthUniverses.json"
     )
@@ -188,7 +244,7 @@ var resolveSnapshotFingerprint = async (projectRoot, relativePath) => {
   if (snapshotFingerprintCache.has(cacheKey)) {
     return snapshotFingerprintCache.get(cacheKey) ?? null;
   }
-  const content = await readOptionalFile(import_node_path.default.join(projectRoot, relativePath));
+  const content = await readOptionalFile(import_node_path2.default.join(projectRoot, relativePath));
   let result = null;
   if (content) {
     try {
@@ -201,55 +257,26 @@ var resolveSnapshotFingerprint = async (projectRoot, relativePath) => {
   snapshotFingerprintCache.set(cacheKey, result);
   return result;
 };
-var resolveGateFingerprint = async ({
+var resolveRuntimeGateFingerprint = async ({
   projectRoot,
   strategyName,
   gitSha
 }) => {
   const cacheKey = `${projectRoot}:${strategyName}:${gitSha ?? "unknown"}`;
   const cached = gateFingerprintCache.get(cacheKey);
-  if (cached) {
-    return cached;
-  }
-  const relativeCandidates = [
-    `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/node/src/ai.ts",
-    "packages/core/src/utils/strategyHelpers/signalBuilders.ts"
-  ];
-  const optionalEntries = await Promise.all(
-    relativeCandidates.map(async (relativePath) => {
-      const content = await readOptionalFile(
-        import_node_path.default.join(projectRoot, relativePath)
-      );
-      return content == null ? null : { relativePath, content };
-    })
-  );
-  const sourceEntries = [];
-  for (const entry of optionalEntries) {
-    if (entry != null) {
-      sourceEntries.push(entry);
-    }
-  }
-  const hash = (0, import_node_crypto.createHash)("sha256");
-  hash.update(strategyName);
-  if (sourceEntries.length) {
-    for (const entry of sourceEntries) {
-      hash.update(entry.relativePath);
-      hash.update(entry.content);
-    }
-  } else {
-    hash.update(gitSha ?? "unknown-git-sha");
-  }
-  const fingerprint = hash.digest("hex").slice(0, 16);
-  gateFingerprintCache.set(cacheKey, fingerprint);
-  return fingerprint;
+  if (cached) return cached;
+  const result = await resolveStrategyGateFingerprint({
+    projectRoot,
+    strategyName,
+    gitSha
+  });
+  gateFingerprintCache.set(cacheKey, result);
+  return result;
 };
 var buildRuntimeLineage = async ({
   projectRoot,
   strategyName,
+  compositionId,
   config,
   runContext,
   env = process.env
@@ -275,19 +302,25 @@ var buildRuntimeLineage = async ({
   };
   return {
     schemaVersion: 1,
+    compositionId: compositionId?.trim() || null,
     ...git,
-    gateFingerprint: await resolveGateFingerprint({
+    gateFingerprint: (await resolveRuntimeGateFingerprint({
       projectRoot,
       strategyName,
       gitSha: git.gitSha
-    }),
-    configFingerprint: fingerprintRuntimeValue(config),
+    })).gateFingerprint,
+    // Position risk is tracked separately so changing trade size does not
+    // masquerade as a change to the core + gate decision logic.
+    configFingerprint: fingerprintRuntimeValue(
+      normalizeRuntimeLogicConfig(config)
+    ),
     contextFingerprint: fingerprintRuntimeValue(context),
     maxLossValue: resolveRuntimeMaxLossValue(config)
   };
 };
 var runtimeLineageKey = (lineage) => [
   lineage.schemaVersion,
+  lineage.compositionId ?? "unbound-composition",
   lineage.gitSha ?? "unknown",
   lineage.gitDirty == null ? "unknown" : lineage.gitDirty ? "dirty" : "clean",
   lineage.gateFingerprint,

package/dist/lib/runtimeScorecard.js

@@ -47,6 +47,71 @@ var extractRuntimeRows = (artifact) => {
     statsBuckets: asArray(runtime.evaluationStatsBuckets).map(asRecord).filter((item) => item != null)
   };
 };
+var buildRuntimeLineageSummary = (rows) => {
+  const lineageRows = [...rows.evaluations, ...rows.signals, ...rows.trades];
+  const lineages = lineageRows.map((row) => asRecord(row.runtimeLineage)).filter((lineage) => lineage != null);
+  const identities = /* @__PURE__ */ new Map();
+  for (const lineage of lineages) {
+    const identity2 = {
+      compositionId: finiteString(lineage.compositionId),
+      gitSha: finiteString(lineage.gitSha),
+      gitDirty: typeof lineage.gitDirty === "boolean" ? lineage.gitDirty : null,
+      gateFingerprint: finiteString(lineage.gateFingerprint),
+      configFingerprint: finiteString(lineage.configFingerprint),
+      contextFingerprint: finiteString(lineage.contextFingerprint),
+      maxLossValue: finiteNumber(lineage.maxLossValue)
+    };
+    identities.set(JSON.stringify(identity2), identity2);
+  }
+  const identity = identities.size === 1 ? [...identities.values()][0] : null;
+  const complete = lineageRows.length > 0 && lineages.length === lineageRows.length && identity != null && identity.compositionId != null && identity.gitSha != null && identity.gitDirty === false && identity.gateFingerprint != null && identity.configFingerprint != null && identity.contextFingerprint != null && identity.maxLossValue != null;
+  return {
+    complete,
+    conflicts: identities.size > 1,
+    rows: lineageRows.length,
+    rowsWithLineage: lineages.length,
+    compositionId: finiteString(identity?.compositionId),
+    gitSha: finiteString(identity?.gitSha),
+    gitDirty: typeof identity?.gitDirty === "boolean" ? identity.gitDirty : null,
+    gateFingerprint: finiteString(identity?.gateFingerprint),
+    configFingerprint: finiteString(identity?.configFingerprint),
+    contextFingerprint: finiteString(identity?.contextFingerprint),
+    maxLossValue: finiteNumber(identity?.maxLossValue)
+  };
+};
+var belongsToStrategy = (row, strategy) => strategy == null || finiteString(row.strategy) === strategy;
+var filterArtifactByStrategy = (artifact, strategy) => {
+  if (!strategy) return artifact;
+  const root = asRecord(artifact) ?? {};
+  const runtime = runtimePayload(artifact);
+  return {
+    ...root,
+    runtime: {
+      ...runtime,
+      evaluations: asArray(runtime.evaluations).filter(
+        (item) => belongsToStrategy(
+          asRecord(asRecord(item)?.evaluation) ?? asRecord(item) ?? {},
+          strategy
+        )
+      ),
+      signals: asArray(runtime.signals).filter(
+        (item) => belongsToStrategy(
+          asRecord(asRecord(item)?.signal) ?? asRecord(item) ?? {},
+          strategy
+        )
+      ),
+      trades: asArray(runtime.trades).filter(
+        (item) => belongsToStrategy(
+          asRecord(asRecord(item)?.trade) ?? asRecord(item) ?? {},
+          strategy
+        )
+      ),
+      evaluationStatsBuckets: asArray(runtime.evaluationStatsBuckets).filter(
+        (item) => belongsToStrategy(asRecord(item) ?? {}, strategy)
+      )
+    }
+  };
+};
 var countBy = (items, getter) => {
   const counts = {};
   for (const item of items) {
@@ -165,14 +230,43 @@ var getReplayComparison = (artifact) => {
   const root = asRecord(artifact) ?? {};
   return asRecord(asRecord(root.replay)?.runtimeComparison) ?? null;
 };
+var replayCountsForStrategy = (replayComparison, strategy) => {
+  if (strategy) {
+    const byStrategy = asRecord(replayComparison?.byStrategy);
+    const strategyCounts = asRecord(byStrategy?.[strategy]);
+    if (strategyCounts) {
+      return {
+        matched: finiteNumber(strategyCounts.matched) ?? 0,
+        backtestOnly: finiteNumber(strategyCounts.backtestOnly) ?? 0,
+        runtimeOnly: finiteNumber(strategyCounts.runtimeOnly) ?? 0
+      };
+    }
+  }
+  const counts = asRecord(replayComparison?.counts);
+  return {
+    matched: finiteNumber(counts?.matched) ?? 0,
+    backtestOnly: finiteNumber(counts?.backtestOnly) ?? 0,
+    runtimeOnly: finiteNumber(counts?.runtimeOnly) ?? 0
+  };
+};
 var getCalibrationSummary = (artifact) => {
   const root = asRecord(artifact) ?? {};
   return asRecord(asRecord(root.summary)?.all) ?? null;
 };
+var getProspectiveSummary = (artifact) => {
+  const root = asRecord(artifact);
+  if (!root || root.reportType !== "strategy-prospective-evidence") return null;
+  return {
+    rawCoreExpectancy: finiteNumber(root.rawCoreExpectancy),
+    aiGateExpectancy: finiteNumber(root.aiGateExpectancy),
+    regimeCoverage: finiteNumber(root.regimeCoverage)
+  };
+};
 var buildRuntimeScorecard = ({
   runtimeArtifact,
   replayEvidenceArtifact,
   calibrationArtifact,
+  prospectiveEvidenceArtifact,
   historyRuntimeArtifacts = [],
   thresholds = {
     minimumParityRatio: 0.95,
@@ -180,9 +274,19 @@ var buildRuntimeScorecard = ({
     minimumClosedTrades: 20,
     minimumExpectancy: 0
   },
-  generatedAt = Date.now()
+  generatedAt = Date.now(),
+  strategy = null,
+  llmComparatorPolicy = "ai_approved_only"
 }) => {
-  const rows = extractRuntimeRows(runtimeArtifact);
+  const scopedRuntimeArtifact = filterArtifactByStrategy(
+    runtimeArtifact,
+    strategy
+  );
+  const scopedHistoryArtifacts = historyRuntimeArtifacts.map(
+    (artifact) => filterArtifactByStrategy(artifact, strategy)
+  );
+  const rows = extractRuntimeRows(scopedRuntimeArtifact);
+  const runtimeLineage = buildRuntimeLineageSummary(rows);
   const window = runtimeWindow(runtimeArtifact);
   const startTime = finiteNumber(window.startTime) ?? generatedAt - 864e5;
   const endTime = finiteNumber(window.endTime) ?? generatedAt;
@@ -197,6 +301,20 @@ var buildRuntimeScorecard = ({
   })).filter(
     ({ decision }) => decision === "approved" || decision === "rejected"
   );
+  const llmEligibleEvaluations = llmComparatorPolicy === "disabled" ? [] : llmComparatorPolicy === "ai_approved_only" ? signalEvaluations.filter(
+    (evaluation) => finiteString(asRecord(evaluation.aiAnalysis)?.gateDecision) === "approved"
+  ) : signalEvaluations;
+  const gateComparisons = llmEligibleEvaluations.map((evaluation) => {
+    const analysis = asRecord(evaluation.aiAnalysis);
+    const gateDecision = finiteString(analysis?.gateDecision);
+    const llmDecision = finiteString(analysis?.llmDecision);
+    if (gateDecision !== "approved" && gateDecision !== "rejected" || llmDecision !== "approved" && llmDecision !== "rejected") {
+      return null;
+    }
+    return { gateDecision, llmDecision };
+  }).filter(
+    (comparison) => Boolean(comparison)
+  );
   const allocatorDecisions = signalEvaluations.map((evaluation) => asRecord(evaluation.allocatorDecision)).filter((item) => item != null);
   const riskDecisions = signalEvaluations.map((evaluation) => asRecord(evaluation.riskDecision)).filter((item) => item != null);
   const orderAttempts = rows.signals.filter(
@@ -207,27 +325,30 @@ var buildRuntimeScorecard = ({
     return trade.status === "closed" && exitTimestamp != null && exitTimestamp >= startTime && exitTimestamp < endTime;
   });
   const replayComparison = getReplayComparison(replayEvidenceArtifact);
-  const replayCounts = asRecord(replayComparison?.counts);
-  const matched = finiteNumber(replayCounts?.matched) ?? 0;
-  const backtestOnly = finiteNumber(replayCounts?.backtestOnly) ?? 0;
-  const runtimeOnly = finiteNumber(replayCounts?.runtimeOnly) ?? 0;
+  const replayCounts = replayCountsForStrategy(replayComparison, strategy);
+  const matched = replayCounts.matched;
+  const backtestOnly = replayCounts.backtestOnly;
+  const runtimeOnly = replayCounts.runtimeOnly;
   const comparisonTotal = matched + backtestOnly + runtimeOnly;
   const parityRatio = comparisonTotal > 0 ? matched / comparisonTotal : null;
   const lineage = asRecord(replayComparison?.lineage);
   const lineageReason = finiteString(lineage?.reason);
-  const calibration = getCalibrationSummary(calibrationArtifact);
+  const calibrationRoot = asRecord(calibrationArtifact) ?? {};
+  const calibrationSummary = asRecord(calibrationRoot.summary);
+  const calibration = strategy ? asRecord(asRecord(calibrationSummary?.byStrategy)?.[strategy]) : getCalibrationSummary(calibrationArtifact);
   const actualSlippageBps = finiteNumber(
     asRecord(calibration?.signalToFillAdverseBps)?.avg
   );
   const residualVsModelBps = finiteNumber(
     asRecord(calibration?.residualVsCurrentModelBps)?.avg
   );
+  const prospective = getProspectiveSummary(prospectiveEvidenceArtifact);
   const historyTrades = dedupeTrades([
-    ...historyRuntimeArtifacts,
-    runtimeArtifact
+    ...scopedHistoryArtifacts,
+    scopedRuntimeArtifact
   ]);
   const currentDistributions = buildDistributions(rows);
-  const previousArtifact = historyRuntimeArtifacts.map((artifact) => ({ artifact, window: runtimeWindow(artifact) })).filter(({ window: candidateWindow }) => {
+  const previousArtifact = scopedHistoryArtifacts.map((artifact) => ({ artifact, window: runtimeWindow(artifact) })).filter(({ window: candidateWindow }) => {
     const candidateEndTime = finiteNumber(candidateWindow.endTime);
     return candidateEndTime != null && candidateEndTime <= startTime;
   }).sort(
@@ -286,6 +407,8 @@ var buildRuntimeScorecard = ({
     schemaVersion: 1,
     generatedAt,
     window: { startTime, endTime },
+    strategy,
+    lineage: runtimeLineage,
     promotionStatus,
     thresholds,
     funnel: {
@@ -342,6 +465,24 @@ var buildRuntimeScorecard = ({
         currentClosedTrades.map((trade) => finiteNumber(trade.fundingFee))
       )
     },
+    gateComparison: {
+      policy: llmComparatorPolicy,
+      eligible: llmEligibleEvaluations.length,
+      compared: gateComparisons.length,
+      coverage: llmEligibleEvaluations.length ? round(gateComparisons.length / llmEligibleEvaluations.length) : null,
+      agreements: gateComparisons.filter(
+        (comparison) => comparison.gateDecision === comparison.llmDecision
+      ).length,
+      disagreements: gateComparisons.filter(
+        (comparison) => comparison.gateDecision !== comparison.llmDecision
+      ).length,
+      gateApprovedLlmRejected: gateComparisons.filter(
+        (comparison) => comparison.gateDecision === "approved" && comparison.llmDecision === "rejected"
+      ).length,
+      gateRejectedLlmApproved: gateComparisons.filter(
+        (comparison) => comparison.gateDecision === "rejected" && comparison.llmDecision === "approved"
+      ).length
+    },
     parity: {
       available: comparisonTotal > 0,
       matched,
@@ -355,6 +496,7 @@ var buildRuntimeScorecard = ({
       actualSignalToFillSlippageBps: actualSlippageBps,
       residualVsCurrentModelBps: residualVsModelBps
     },
+    prospective,
     rolling,
     distributions: currentDistributions,
     distributionChanges: {
@@ -407,6 +549,7 @@ Window: ${new Date(scorecard.window.startTime).toISOString()} \u2014 ${new Date(
 - Evaluations: ${scorecard.funnel.evaluations}
 - Core candidates: ${scorecard.funnel.coreCandidates}
 - Gate approvals/rejects: ${scorecard.funnel.gate.approved}/${scorecard.funnel.gate.rejected}
+- AI / LLM disagreement: ${scorecard.gateComparison.disagreements}/${scorecard.gateComparison.compared}
 - Allocator approvals/rejects: ${scorecard.funnel.allocator.available ? `${scorecard.funnel.allocator.approved}/${scorecard.funnel.allocator.rejected}` : "unavailable"}
 - Risk approvals/rejects: ${scorecard.funnel.risk.available ? `${scorecard.funnel.risk.approved}/${scorecard.funnel.risk.rejected}` : "unavailable"}
 - Order attempts/failures: ${scorecard.funnel.orderAttempts}/${scorecard.funnel.orderFailures}

package/dist/lib/strategyGateFingerprint.js

@@ -0,0 +1,80 @@
+"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/lib/strategyGateFingerprint.ts
+var strategyGateFingerprint_exports = {};
+__export(strategyGateFingerprint_exports, {
+  resolveStrategyGateFingerprint: () => resolveStrategyGateFingerprint
+});
+module.exports = __toCommonJS(strategyGateFingerprint_exports);
+var import_node_crypto = require("crypto");
+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 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 sourceEntries = candidates.filter(
+    (entry) => entry != null
+  );
+  const hash = (0, import_node_crypto.createHash)("sha256");
+  hash.update(strategyName);
+  if (sourceEntries.length) {
+    for (const entry of sourceEntries) {
+      hash.update(entry.relativePath);
+      hash.update(entry.content);
+    }
+  } else {
+    hash.update(gitSha ?? "unknown-git-sha");
+  }
+  return {
+    gateFingerprint: hash.digest("hex").slice(0, 16),
+    gateFingerprintFiles: sourceEntries.map((entry) => entry.relativePath)
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  resolveStrategyGateFingerprint
+});